System.Data.SQLite
Check-in [ec79fb3446]
Not logged in

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Add preliminary support for .NET Core 2.0 and the .NET Standard 2.0. Pursuant to [5c89cecd1b].
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: ec79fb34467f1822ab022c4826e604dfb0b408c5
User & Date: mistachkin 2018-04-26 01:16:57
Original Comment: Add preliminary support for .NET Core 2.0 and the .NET Standard 2.0.
Context
2018-04-26
01:26
Update version history docs. check-in: aefe29ee3e user: mistachkin tags: trunk
01:16
Add preliminary support for .NET Core 2.0 and the .NET Standard 2.0. Pursuant to [5c89cecd1b]. check-in: ec79fb3446 user: mistachkin tags: trunk
2018-04-25
22:33
Enhance the native library pre-loader platform abstraction subsystem to support querying the machine name. Closed-Leaf check-in: 2e3be13ffa user: mistachkin tags: netStandard20
21:19
Change test suite infrastructure for a pending upstream change in order to support .NET Core 2.0. check-in: 08b72a8690 user: mistachkin tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to .fossil-settings/ignore-glob.

     1         -Externals/Eagle/bin/Eagle*.pdb
     2         -Externals/Eagle/bin/x64/Spilornis.pdb
     3         -Externals/Eagle/bin/x86/Spilornis.pdb
            1  +Externals/Eagle/bin/netFramework40/Eagle*.pdb
            2  +Externals/Eagle/bin/netFramework40/x64/Spilornis.pdb
            3  +Externals/Eagle/bin/netFramework40/x86/Spilornis.pdb
            4  +Externals/Eagle/bin/netStandard20/Eagle*.pdb

Changes to Doc/Extra/Provider/environment.html.

   183    183             <td>No_SQLiteXmlConfigFile</td>
   184    184             <td>If this environment variable is set [to anything], calls to the
   185    185             GetSettingValue method will never result in the XML configuration
   186    186             file being read; instead, the default value will be returned.  This
   187    187             will effectively prevent any setting values specified via the XML
   188    188             configuration file from having any effect.</td>
   189    189           </tr>
          190  +        <tr valign="top">
          191  +          <td>PreLoadSQLite_AllowBaseDirectoryOnly</td>
          192  +          <td>If this environment variable is set [to anything], the base
          193  +          directory itself is considered valid for pre-loading the native
          194  +          SQLite library.</td>
          195  +        </tr>
   190    196           <tr valign="top">
   191    197             <td>PreLoadSQLite_BaseDirectory</td>
   192    198             <td>If this environment variable is set [to anything], it will be
   193    199             used instead of the application base directory by the native
   194    200             library pre-loader.  This environment variable can be especially
   195    201             useful in ASP.NET and other hosted environments where direct control
   196    202             of the location of the managed assemblies is not under the control
   197    203             of the application.</td>
   198    204           </tr>
   199    205           <tr valign="top">
   200    206             <td>PreLoadSQLite_BreakIntoDebugger</td>
   201         -          <td>If this configuration variable is set [to anything], the native
          207  +          <td>If this environment variable is set [to anything], the native
   202    208             library pre-loader subsystem will attempt to give the interactive
   203    209             user an opportunity to attach a debugger to the current process.</td>
   204    210           </tr>
   205    211           <tr valign="top">
   206    212             <td>PreLoadSQLite_LibraryFileNameOnly</td>
   207    213             <td>If this environment variable is set [to anything], it will be
   208    214             used as the base file name (without directory information) for the

Changes to Doc/Extra/Provider/version.html.

    43     43       <div id="mainSection">
    44     44       <div id="mainBody">
    45     45       <h1 class="heading">Version History</h1>
    46     46       <p><b>1.0.109.0 - May XX, 2018 <font color="red">(release scheduled)</font></b></p>
    47     47       <ul>
    48     48         <li>Updated to <a href="https://www.sqlite.org/releaselog/3_23_1.html">SQLite 3.23.1</a>.</li>
    49     49         <li>Prevent GetSchemaTable from throwing InvalidCastException. Fix for <a href="https://system.data.sqlite.org/index.html/info/baf42ee135">[baf42ee135]</a>.</li>
           50  +      <li>Add preliminary support for .NET Core 2.0 and the .NET Standard 2.0.</li>
    50     51         <li>Add simpler overload for the SQLiteBlob.Create method. Pursuant to <a href="https://system.data.sqlite.org/index.html/info/dfc8133ba2">[dfc8133ba2]</a>.</li>
    51     52         <li>Add GetFieldAffinity method to the SQLiteDataReader class.</li>
    52     53       </ul>
    53     54       <p><b>1.0.108.0 - March 2, 2018</b></p>
    54     55       <ul>
    55     56         <li>Support extended result codes when messages are looked up without the SQLite core library.</li>
    56     57         <li>Override System.Object members for the SQLiteException class to improve its ToString return value. Pursuant to <a href="https://system.data.sqlite.org/index.html/info/53962f9eff">[53962f9eff]</a>.</li>

Name change from Externals/Eagle/bin/Eagle.dll to Externals/Eagle/bin/netFramework40/Eagle.dll.

cannot compute difference between binary files

Name change from Externals/Eagle/bin/EagleShell.exe to Externals/Eagle/bin/netFramework40/EagleShell.exe.

cannot compute difference between binary files

Name change from Externals/Eagle/bin/EagleShell.exe.config to Externals/Eagle/bin/netFramework40/EagleShell.exe.config.


Name change from Externals/Eagle/bin/EagleShell.exe.mda.config to Externals/Eagle/bin/netFramework40/EagleShell.exe.mda.config.


Name change from Externals/Eagle/bin/EagleShell32.exe to Externals/Eagle/bin/netFramework40/EagleShell32.exe.

cannot compute difference between binary files

Name change from Externals/Eagle/bin/x64/Spilornis.dll to Externals/Eagle/bin/netFramework40/x64/Spilornis.dll.

cannot compute difference between binary files

Name change from Externals/Eagle/bin/x86/Spilornis.dll to Externals/Eagle/bin/netFramework40/x86/Spilornis.dll.

cannot compute difference between binary files

Changes to Externals/Eagle/lib/Eagle1.0/csharp.eagle.

    17     17   #
    18     18   # NOTE: Use our own namespace here because even though we do not directly
    19     19   #       support namespaces ourselves, we do not want to pollute the global
    20     20   #       namespace if this script actually ends up being evaluated in Tcl.
    21     21   #
    22     22   namespace eval ::Eagle {
    23     23     #
    24         -  # NOTE: This procedure is used to dynamically compile some C# code from
    25         -  #       within a script.  While this procedure was originally designed
    26         -  #       to be used by the test suite, it can be quite useful in non-test
           24  +  # NOTE: This procedure is used to determine the fully qualified path to the
           25  +  #       .NET Core SDK.  An empty string will be returned to indicate an
           26  +  #       error.  This procedure should not raise script errors.
           27  +  #
           28  +  proc getDotNetCoreSdkPath {} {
           29  +    if {[catch {exec -- dotnet --info} info] == 0} then {
           30  +      set info [string map [list \r\n \n] $info]
           31  +
           32  +      if {[regexp -line -- \
           33  +          {^\s*Base Path:\s+([^\n]+)$} $info dummy path]} then {
           34  +        return [file normalize $path]
           35  +      }
           36  +    }
           37  +
           38  +    return ""
           39  +  }
           40  +
           41  +  #
           42  +  # NOTE: This procedure is used to determine the fully qualified path to the
           43  +  #       directory containing the reference assemblies for the .NET Standard
           44  +  #       2.0.  An empty string will be returned to indicate an error.  This
           45  +  #       procedure should not raise script errors.
           46  +  #
           47  +  proc getDotNetStandardReferencePath {
           48  +          {packageVersion ""} {standardVersion netstandard2.0} } {
           49  +    set path [getDotNetCoreSdkPath]
           50  +
           51  +    if {[string length $path] > 0} then {
           52  +      set libraryDirectory [file normalize [file join \
           53  +          [file dirname $path] NuGetFallbackFolder netstandard.library]]
           54  +
           55  +      set buildReferenceSubDirectory [file join build $standardVersion ref]
           56  +
           57  +      if {[string length $packageVersion] > 0} then {
           58  +        set assemblyDirectory [file normalize [file join \
           59  +            $libraryDirectory $packageVersion $buildReferenceSubDirectory]]
           60  +
           61  +        if {[file exists $assemblyDirectory]} then {
           62  +          return $assemblyDirectory
           63  +        }
           64  +      } else {
           65  +        set globPathPattern [file join $libraryDirectory *]
           66  +
           67  +        set maybeVersions [lsort -decreasing -command [list package vsort] \
           68  +            [lmap directory [glob -nocomplain -types {d} $globPathPattern] \
           69  +            { file tail $directory }]]
           70  +
           71  +        foreach maybeVersion $maybeVersions {
           72  +          set assemblyDirectory [file normalize [file join \
           73  +              $libraryDirectory $maybeVersion $buildReferenceSubDirectory]]
           74  +
           75  +          if {[file exists $assemblyDirectory]} then {
           76  +            return $assemblyDirectory
           77  +          }
           78  +        }
           79  +      }
           80  +    }
           81  +
           82  +    return ""
           83  +  }
           84  +
           85  +  #
           86  +  # NOTE: This procedure is used to obtain a test program for use with the
           87  +  #       C# compiler.  Upon success, the return value will be a list with
           88  +  #       two elements.  The first element will be the name of the C# class
           89  +  #       to be compiled.  The second element will be the C# program text.
           90  +  #       Upon failure, the return value will be an empty list.
           91  +  #
           92  +  proc getCSharpTestProgram { {name ""} } {
           93  +    set prefix Test
           94  +    set id [object invoke Interpreter.GetActive NextId]
           95  +
           96  +    set className [appendArgs \
           97  +        $prefix Namespace $id [object invoke Type Delimiter] \
           98  +        $prefix Class $id]
           99  +
          100  +    return [list $className [subst {
          101  +      using System;
          102  +
          103  +      namespace ${prefix}Namespace${id}
          104  +      {
          105  +        public static class ${prefix}Class${id}
          106  +        {
          107  +          public static Int32 Main(String\[\] args)
          108  +          {
          109  +            return 0;
          110  +          }
          111  +        }
          112  +      }
          113  +    }]]
          114  +  }
          115  +
          116  +  #
          117  +  # NOTE: This procedure is used to determine whether the C# compiler appears
          118  +  #       to work when invoked via the interfaces defined in this script file.
          119  +  #       Non-zero is returned to indicate success.  This procedure should not
          120  +  #       raise script errors.
          121  +  #
          122  +  proc doesCompileCSharpWork { {name ""} } {
          123  +    if {[catch {getCSharpTestProgram $name} program]} then {
          124  +      return false
          125  +    }
          126  +
          127  +    if {[llength $program] < 2} then {
          128  +      return false
          129  +    }
          130  +
          131  +    unset -nocomplain results errors
          132  +
          133  +    if {[catch {
          134  +      compileCSharp [lindex $program 1] true true true results errors
          135  +    } code]} then {
          136  +      return false
          137  +    }
          138  +
          139  +    if {$code ne "Ok"} then {
          140  +      return false
          141  +    }
          142  +
          143  +    if {[catch {
          144  +      object invoke [lindex $program 0] Main null
          145  +    } exitCode]} then {
          146  +      return false
          147  +    }
          148  +
          149  +    if {$exitCode ne "0"} then {
          150  +      return false
          151  +    }
          152  +
          153  +    return true
          154  +  }
          155  +
          156  +  #
          157  +  # NOTE: This procedure is used to determine the command line arguments that
          158  +  #       are required to invoke the .NET Core SDK compiler for C#.  An empty
          159  +  #       list will be returned if the arguments cannot be determined for some
          160  +  #       reason -OR- the C# compiler cannot be found.  This procedure should
          161  +  #       not raise script errors.
          162  +  #
          163  +  proc getDotNetCoreCSharpCommandArgs {} {
          164  +    set path [getDotNetCoreSdkPath]
          165  +
          166  +    if {[string length $path] > 0} then {
          167  +      set compilerFileName [file normalize [file join \
          168  +          $path Roslyn bincore csc.dll]]
          169  +
          170  +      if {[file exists $compilerFileName]} then {
          171  +        return [list dotnet exec [appendArgs \
          172  +            \" [file nativename $compilerFileName] \"]]
          173  +      }
          174  +    }
          175  +
          176  +    return [list]
          177  +  }
          178  +
          179  +  #
          180  +  # NOTE: This procedure is used to format an option to the C# compiler.  It
          181  +  #       may have a name and/or a value.  This procedure should not raise
          182  +  #       script errors.
          183  +  #
          184  +  proc formatCompilerArgument { name value } {
          185  +    set wrap ""
          186  +
          187  +    if {[regexp -- {\s} $name] || [regexp -- {\s} $value]} then {
          188  +      set wrap \"
          189  +    }
          190  +
          191  +    if {[string length $name] > 0} then {
          192  +      if {[string length $value] > 0} then {
          193  +        return [appendArgs $wrap $name : $value $wrap]
          194  +      } else {
          195  +        return [appendArgs $wrap $name $wrap]
          196  +      }
          197  +    } else {
          198  +      if {[string length $value] > 0} then {
          199  +        return [appendArgs $wrap $value $wrap]
          200  +      } else {
          201  +        return ""
          202  +      }
          203  +    }
          204  +  }
          205  +
          206  +  #
          207  +  # NOTE: This procedure is used to translate a name/value pair into zero or
          208  +  #       more options to the C# compiler.  This procedure should not raise
          209  +  #       script errors.
          210  +  #
          211  +  proc compilerParameterToArguments {
          212  +          name {value ""} {outputAssemblyVarName ""} } {
          213  +    switch -exact -nocase -- $name {
          214  +      WarningLevel {
          215  +        set name -warn
          216  +      }
          217  +      TreatWarningsAsErrors {
          218  +        set name -warnaserror
          219  +      }
          220  +      OutputAssembly {
          221  +        if {[string length $outputAssemblyVarName] > 0} then {
          222  +          #
          223  +          # HACK: This compiler parameter is handled by our caller; however,
          224  +          #       we want to honor the value specified via the OutputAssembly
          225  +          #       property.  Therefore, reset the specified variable from the
          226  +          #       caller to the new value.
          227  +          #
          228  +          upvar 1 $outputAssemblyVarName outputAssembly
          229  +
          230  +          #
          231  +          # NOTE: Use the file name value specified by the caller verbatim.
          232  +          #
          233  +          set outputAssembly $value
          234  +
          235  +          #
          236  +          # HACK: Also, make sure that we do not handle this parameter again,
          237  +          #       below.
          238  +          #
          239  +          set name ""; set value ""
          240  +        } else {
          241  +          #
          242  +          # BUGBUG: Translate the compiler parameter; however, this may not
          243  +          #         actually work, depending on how our caller handles its
          244  +          #         output assembly file name.  At the time this block was
          245  +          #         originally written (2018-04-09), the only caller (i.e.
          246  +          #         [compileViaDotNetCoreCSharp]) always passed the output
          247  +          #         assembly variable name, making this a non-issue.  This
          248  +          #         convention should also be followed by future callers of
          249  +          #         this procedure.
          250  +          #
          251  +          set name -out
          252  +        }
          253  +      }
          254  +      ReferencedAssemblies.Add {
          255  +        set name -reference
          256  +
          257  +        if {[file pathtype $value] ne "absolute"} then {
          258  +          set value [file nativename [file normalize \
          259  +              [file join [getDotNetStandardReferencePath] \
          260  +              $value]]]
          261  +        }
          262  +      }
          263  +    }
          264  +
          265  +    set formatted [formatCompilerArgument $name $value]
          266  +
          267  +    if {[string length $formatted] > 0} then {
          268  +      return [list $formatted]
          269  +    } else {
          270  +      return [list]
          271  +    }
          272  +  }
          273  +
          274  +  #
          275  +  # NOTE: This procedure is used to obtain the base command line options for
          276  +  #       the C# compiler, including those that may be enabled by default.
          277  +  #       An empty string may be returned.  This procedure should not raise
          278  +  #       script errors.
          279  +  #
          280  +  proc getCSharpCompilerOptions { parameters library csharp prefix } {
          281  +    #
          282  +    # NOTE: Make sure that the "standard" preprocessor defines match those
          283  +    #       for the platform (i.e. the ones used to compile the Eagle core
          284  +    #       library assembly).  This caller may disable this handling.
          285  +    #
          286  +    if {$library} then {
          287  +      set libraryOptions [expr { \
          288  +          [info exists ::eagle_platform(compileOptions)] ? \
          289  +          $::eagle_platform(compileOptions) : [list] \
          290  +      }]
          291  +    } else {
          292  +      set libraryOptions ""
          293  +    }
          294  +
          295  +    #
          296  +    # NOTE: Permit extra C# compiler options to be passed via the global
          297  +    #       array element "csharpOptions", if it exists.  This caller may
          298  +    #       disable this handling.
          299  +    #
          300  +    if {$csharp} then {
          301  +      set csharpOptions [expr { \
          302  +          [info exists ::eagle_platform(csharpOptions)] ? \
          303  +          $::eagle_platform(csharpOptions) : [list] \
          304  +      }]
          305  +    } else {
          306  +      set csharpOptions ""
          307  +    }
          308  +
          309  +    #
          310  +    # NOTE: Start out with no compiler options.
          311  +    #
          312  +    set result ""
          313  +
          314  +    #
          315  +    # NOTE: Grab the existing compiler options, if any.  This caller may
          316  +    #       disable this handling (e.g. by specifying an invalid opaque
          317  +    #       object handle for the "parameters" argument).
          318  +    #
          319  +    if {[isNonNullObjectHandle $parameters]} then {
          320  +      if {[string length $result] > 0} then {
          321  +        append result " "
          322  +      }
          323  +
          324  +      append result [$parameters CompilerOptions]
          325  +    }
          326  +
          327  +    #
          328  +    # NOTE: Are there any Eagle core library options to check?
          329  +    #
          330  +    if {[llength $libraryOptions] > 0} then {
          331  +      #
          332  +      # NOTE: Was the Eagle core library built in the Debug configuration?
          333  +      #
          334  +      if {"DEBUG" in $libraryOptions} then {
          335  +        if {[string length $result] > 0} then {
          336  +          append result " "
          337  +        }
          338  +
          339  +        append result $prefix define:DEBUG
          340  +      }
          341  +
          342  +      #
          343  +      # NOTE: Was the Eagle core library built with tracing enabled (i.e.
          344  +      #       this allows for use of System.Diagnostics.Trace, etc)?
          345  +      #
          346  +      if {"TRACE" in $libraryOptions} then {
          347  +        if {[string length $result] > 0} then {
          348  +          append result " "
          349  +        }
          350  +
          351  +        append result $prefix define:TRACE
          352  +      }
          353  +    }
          354  +
          355  +    #
          356  +    # NOTE: Are there any extra C# compiler options to add?
          357  +    #
          358  +    if {[llength $csharpOptions] > 0} then {
          359  +      #
          360  +      # NOTE: Append the configured extra C# compiler options configured
          361  +      #       via the global array element "csharpOptions", if any.
          362  +      #
          363  +      foreach csharpOption $csharpOptions {
          364  +        if {[string length $result] > 0} then {
          365  +          append result " "
          366  +        }
          367  +
          368  +        append result $csharpOption
          369  +      }
          370  +    }
          371  +
          372  +    return $result
          373  +  }
          374  +
          375  +  #
          376  +  # NOTE: This procedure is used to escape all characters in the specified
          377  +  #       string for use inside of a regular expression.  An empty string
          378  +  #       may be returned.  This procedure should not raise script errors.
          379  +  #
          380  +  proc regexpEscapeAll { value } {
          381  +    set result ""
          382  +
          383  +    foreach char [split $value ""] {
          384  +      append result \\u [format %04X [string ordinal $char 0]]
          385  +    }
          386  +
          387  +    return $result
          388  +  }
          389  +
          390  +  #
          391  +  # NOTE: This procedure is used to execute the C# compiler and returns its
          392  +  #       platform normalized results.
          393  +  #
          394  +  proc runDotNetCSharpCommand { command } {
          395  +    #
          396  +    # NOTE: Evaluate the [exec] command constructed by our caller, in their
          397  +    #       context, and return the results, with line-endings normalized.
          398  +    #
          399  +    return [string map [list \r\n \n] [uplevel 1 $command]]
          400  +  }
          401  +
          402  +  #
          403  +  # NOTE: This procedure is used to extract the C# compiler error messages
          404  +  #       from its results.  An empty list will be returned if the errors
          405  +  #       cannot be determined for some reason.  This procedure should not
          406  +  #       raise script errors.
          407  +  #
          408  +  proc extractCSharpErrors { fileName results } {
          409  +    set list [list]
          410  +
          411  +    foreach {dummy match} [regexp -all -line -inline -- \
          412  +        [appendArgs (^(?: [regexpEscapeAll $fileName] \
          413  +        {\(\d+,\d+\): )?error CS\d{4}: [^\n]+$)}] $results] {
          414  +      lappend list $match
          415  +    }
          416  +
          417  +    return $list
          418  +  }
          419  +
          420  +  #
          421  +  # NOTE: This procedure is used to extract the C# compiler warning messages
          422  +  #       from its results.  An empty list will be returned if the warnings
          423  +  #       cannot be determined for some reason.  This procedure should not
          424  +  #       raise script errors.
          425  +  #
          426  +  proc extractCSharpWarnings { fileName results } {
          427  +    set list [list]
          428  +
          429  +    foreach {dummy match} [regexp -all -line -inline -- \
          430  +        [appendArgs (^(?: [regexpEscapeAll $fileName] \
          431  +        {\(\d+,\d+\): )?warning CS\d{4}: [^\n]+$)}] $results] {
          432  +      lappend list $match
          433  +    }
          434  +
          435  +    return $list
          436  +  }
          437  +
          438  +  #
          439  +  # NOTE: This procedure is used to dynamically compile arbitrary C# code
          440  +  #       from within a script using the CSharpCodeProvider class present
          441  +  #       in the desktop .NET Framework.  It may work on some versions of
          442  +  #       Mono as well.  This procedure was originally designed to be used
          443  +  #       by the test suite; however, it can be quite useful in non-test
    27    444     #       scripts as well.
    28    445     #
    29         -  proc compileCSharp {
          446  +  proc compileViaCSharpCodeProvider {
    30    447             string memory symbols strict resultsVarName errorsVarName args } {
    31    448       #
    32    449       # NOTE: The [object] command is required by this procedure.  If it
    33    450       #       is not available, bail out now.
    34    451       #
    35    452       if {[llength [info commands object]] == 0} then {
    36    453         #
................................................................................
    67    484       #
    68    485       set parameters [object create -alias \
    69    486           System.CodeDom.Compiler.CompilerParameters]
    70    487   
    71    488       #
    72    489       # NOTE: Do we not want to persist the generated assembly to disk?
    73    490       #
          491  +    set outputFileName ""
          492  +
    74    493       if {$memory} then {
    75    494         $parameters GenerateInMemory true
          495  +    } else {
          496  +      $parameters OutputAssembly \
          497  +          [set outputFileName [appendArgs [file tempname] .dll]]
    76    498       }
    77    499   
    78    500       #
    79    501       # NOTE: Do we want symbols to be generated for the generated assembly?
    80    502       #
    81    503       if {$symbols} then {
    82    504         $parameters IncludeDebugInformation true
    83    505       }
    84    506   
    85    507       #
    86         -    # NOTE: Make sure that the "standard" preprocessor defines match those
    87         -    #       for the platform (i.e. the ones used to compile the Eagle core
    88         -    #       library assembly).
    89         -    #
    90         -    set platformOptions [expr { \
    91         -        [info exists ::eagle_platform(compileOptions)] ? \
    92         -        $::eagle_platform(compileOptions) : [list]}]
    93         -
    94         -    #
    95         -    # NOTE: Permit extra C# compiler options to be passed via the global
    96         -    #       array element "csharpOptions", if it exists.
    97         -    #
    98         -    set csharpOptions [expr { \
    99         -        [info exists ::eagle_platform(csharpOptions)] ? \
   100         -        $::eagle_platform(csharpOptions) : [list]}]
   101         -
   102         -    if {[llength $platformOptions] > 0 || \
   103         -        [llength $csharpOptions] > 0} then {
   104         -      #
   105         -      # NOTE: Grab the existing compiler options, if any.
   106         -      #
   107         -      set compilerOptions [$parameters CompilerOptions]
   108         -
   109         -      if {"DEBUG" in $platformOptions} then {
   110         -        if {[string length $compilerOptions] > 0} then {
   111         -          append compilerOptions " "
   112         -        }
   113         -
   114         -        append compilerOptions /define:DEBUG
   115         -      }
   116         -
   117         -      if {"TRACE" in $platformOptions} then {
   118         -        if {[string length $compilerOptions] > 0} then {
   119         -          append compilerOptions " "
   120         -        }
   121         -
   122         -        append compilerOptions /define:TRACE
   123         -      }
   124         -
   125         -      #
   126         -      # NOTE: Append the configured extra C# compiler options configured
   127         -      #       via the global array element "csharpOptions", if any.
   128         -      #
   129         -      foreach csharpOption $csharpOptions {
   130         -        if {[string length $compilerOptions] > 0} then {
   131         -          append compilerOptions " "
   132         -        }
   133         -
   134         -        append compilerOptions $csharpOption
   135         -      }
   136         -
   137         -      #
   138         -      # NOTE: Reset the compiler options to the pre-existing ones plus the
   139         -      #       extra defines we may have added (above).
   140         -      #
   141         -      $parameters CompilerOptions $compilerOptions
   142         -    }
   143         -
   144         -    #
   145         -    # NOTE: Process any extra compiler settings the caller may have
   146         -    #       provided.
          508  +    # NOTE: Start out the compiler options with the pre-existing defaults
          509  +    #       for the compiler followed by those necessary for the platform.
          510  +    #
          511  +    $parameters CompilerOptions \
          512  +        [getCSharpCompilerOptions $parameters true true /]
          513  +
          514  +    #
          515  +    # NOTE: Process extra compiler settings the caller may have provided.
   147    516       #
   148    517       foreach {name value} $args {
   149    518         $parameters -nocase $name $value
   150    519       }
   151    520   
   152    521       #
   153    522       # NOTE: Prepare to transfer the object reference to the caller.  We
   154         -    #       must use upvar here because otherwise the object is lost when
   155         -    #       the procedure call frame is cleaned up.
          523  +    #       must use [upvar] here because otherwise the object is lost
          524  +    #       when the procedure call frame is cleaned up.
   156    525       #
   157    526       if {[string length $resultsVarName] > 0} then {
   158    527         upvar 1 $resultsVarName results
   159    528       }
   160    529   
   161    530       #
   162    531       # NOTE: Attempt to compile the specified string as C# and capture the
................................................................................
   177    546       set errors [$results -alias Errors]
   178    547   
   179    548       #
   180    549       # NOTE: It is assumed that no assembly was generated if there were
   181    550       #       any compiler errors.  Ignore all compiler warnings unless
   182    551       #       we are in strict mode.
   183    552       #
   184         -    if {[$errors HasErrors] || ($strict && [$errors HasWarnings])} then {
          553  +    if {[$errors HasErrors] || \
          554  +        ($strict && [$errors HasWarnings])} then {
   185    555         #
   186    556         # NOTE: Compilation of the assembly failed.
   187    557         #
   188    558         set code Error
   189    559   
   190    560         #
   191    561         # NOTE: Prepare to transfer error messages to the caller.
   192    562         #
   193    563         if {[string length $errorsVarName] > 0} then {
   194    564           upvar 1 $errorsVarName local_errors
   195    565         }
   196    566   
   197         -      #
   198         -      # NOTE: How many compile errors?
   199         -      #
   200         -      set count [$errors Count]
   201         -
   202    567         #
   203    568         # NOTE: Grab each error object and append the string itself to
   204    569         #       the overall list of errors.
   205    570         #
   206         -      for {set index 0} {$index < $count} {incr index} {
          571  +      for {set index 0} {$index < [$errors Count]} {incr index} {
   207    572           #
   208    573           # NOTE: Get the compiler error object at this index.
   209    574           #
   210    575           set error [$errors -alias Item $index]
   211    576   
   212    577           #
   213    578           # NOTE: Convert it to a string and append it to the list of
................................................................................
   225    590         #
   226    591         # NOTE: Compilation of the assembly succeeded.
   227    592         #
   228    593         set code Ok
   229    594       }
   230    595   
   231    596       #
   232         -    # NOTE: We no longer need the collection of compiler errors;
   233         -    #       therefore, dispose it now.
          597  +    # NOTE: We no longer need the compiler errors collection; therefore,
          598  +    #       dispose it now.
   234    599       #
   235    600       unset errors; # dispose
   236    601   
   237    602       #
   238         -    # NOTE: Return the overall result to the caller.
          603  +    # HACK: *BREAKING CHANGE* If there is an output file name, return it
          604  +    #       as well; otherwise, just return success.
          605  +    #
          606  +    if {[string length $outputFileName] > 0} then {
          607  +      #
          608  +      # NOTE: Return a two element list: the first element is the overall
          609  +      #       result and the second element is the output file name.
          610  +      #
          611  +      return [list $code $outputFileName]
          612  +    } else {
          613  +      #
          614  +      # NOTE: Return the overall result to the caller.
          615  +      #
          616  +      return $code
          617  +    }
          618  +  }
          619  +
          620  +  #
          621  +  # NOTE: This procedure is used to dynamically compile arbitrary C# code
          622  +  #       from within a script using the command line C# compiler provided
          623  +  #       by the .NET Core SDK.  This procedure was originally designed to
          624  +  #       be used by the test suite; however, it can be quite useful in
          625  +  #       non-test scripts as well.
          626  +  #
          627  +  proc compileViaDotNetCoreCSharp {
          628  +          string memory symbols strict resultsVarName errorsVarName args } {
          629  +    #
          630  +    # NOTE: Get the initial command line arguments needed to invoke the C#
          631  +    #       compiler on .NET Core.  If this ends up being invalid, nothing
          632  +    #       else can be done.
          633  +    #
          634  +    set command [getDotNetCoreCSharpCommandArgs]
          635  +
          636  +    if {[llength $command] == 0} then {
          637  +      #
          638  +      # NOTE: We cannot even attempt to compile anything, fail.
          639  +      #
          640  +      set code Error
          641  +
          642  +      #
          643  +      # NOTE: Prepare to transfer error messages to the caller.
          644  +      #
          645  +      if {[string length $errorsVarName] > 0} then {
          646  +        upvar 1 $errorsVarName local_errors
          647  +      }
          648  +
          649  +      #
          650  +      # NOTE: Append to the list of errors.
          651  +      #
          652  +      lappend local_errors "cannot compile, C# compiler was not found"
          653  +
          654  +      #
          655  +      # NOTE: Return the overall result to the caller.
          656  +      #
          657  +      return $code
          658  +    }
          659  +
          660  +    #
          661  +    # NOTE: Insert the [exec] command before the command line arguments.
          662  +    #       The -success option is not used here because we want to handle
          663  +    #       errors (only) by processing the compiler output.
          664  +    #
          665  +    set command [linsert $command 0 exec --]
          666  +
          667  +    #
          668  +    # NOTE: Start out the compiler options with the pre-existing defaults
          669  +    #       for the compiler followed by those necessary for the platform.
          670  +    #
          671  +    append command " " [getCSharpCompilerOptions "" true true -]
          672  +
          673  +    #
          674  +    # NOTE: Allocate a couple temporary file names, one to hold the source
          675  +    #       code to compile and one to hold the generated assembly.
          676  +    #
          677  +    set sourceFileName [appendArgs [file tempname] .cs]
          678  +    set outputFileName [appendArgs [file tempname] .dll]
          679  +
          680  +    #
          681  +    # NOTE: Process extra compiler settings the caller may have provided.
          682  +    #
          683  +    foreach {name value} $args {
          684  +      set nameValueArguments \
          685  +          [compilerParameterToArguments $name $value outputFileName]
          686  +
          687  +      if {[llength $nameValueArguments] > 0} then {
          688  +        eval lappend command $nameValueArguments
          689  +      }
          690  +    }
          691  +
          692  +    try {
          693  +      #
          694  +      # NOTE: Make the compiler output a little quieter.  This is needed
          695  +      #       to maintain compatibility with the results generated by the
          696  +      #       [compileViaCSharpCodeProvider] procedure.
          697  +      #
          698  +      lappend command -nologo
          699  +
          700  +      #
          701  +      # NOTE: Always build as a library so that we do not require a static
          702  +      #       Main method.
          703  +      #
          704  +      lappend command -target:library
          705  +
          706  +      #
          707  +      # NOTE: If symbols are enabled, add the necessary command line
          708  +      #       argument.
          709  +      #
          710  +      if {$symbols} then {lappend command -debug}
          711  +
          712  +      #
          713  +      # NOTE: As of this writing (2018-04-06), the current version of the
          714  +      #       .NET Core SDK (2.1.101) uses the "netstandard.dll" assembly
          715  +      #       to enable use of the .NET Standard 2.0 library.
          716  +      #
          717  +      lappend command [appendArgs \"-reference: [file nativename \
          718  +          [file normalize [file join [getDotNetStandardReferencePath] \
          719  +          netstandard.dll]]] \"]
          720  +
          721  +      #
          722  +      # NOTE: Set the output assembly file name to the temporary output
          723  +      #       file name we obtained from [file tempname] above.
          724  +      #
          725  +      lappend command [appendArgs \"-out: [file nativename [file \
          726  +          normalize $outputFileName]] \"]
          727  +
          728  +      #
          729  +      # NOTE: Set the source code file name to the temporary source code
          730  +      #       file name we obtained from [file tempname] above.
          731  +      #
          732  +      lappend command [appendArgs \" [file nativename [file normalize \
          733  +          $sourceFileName]] \"]
          734  +
          735  +      #
          736  +      # NOTE: First, write the specified string (containing C# code) to
          737  +      #       the temporary source code file.
          738  +      #
          739  +      writeFile $sourceFileName $string
          740  +
          741  +      #
          742  +      # NOTE: Attempt to compile the temporary file as C# and capture the
          743  +      #       results into the variable provided by the caller.  Since the
          744  +      #       results are text, normalize line endings before extracting
          745  +      #       the compiler errors and/or warnings.
          746  +      #
          747  +      set local_results [runDotNetCSharpCommand $command]
          748  +
          749  +      #
          750  +      # NOTE: Extract the compiler errors (which may be empty).
          751  +      #
          752  +      set errors [extractCSharpErrors $sourceFileName $local_results]
          753  +
          754  +      #
          755  +      # NOTE: Extract the compiler warnings (which may be empty).
          756  +      #
          757  +      set warnings [extractCSharpWarnings $sourceFileName $local_results]
          758  +
          759  +      #
          760  +      # NOTE: Prepare to transfer the "results" to the caller.
          761  +      #
          762  +      if {[string length $resultsVarName] > 0} then {
          763  +        upvar 1 $resultsVarName results
          764  +      }
          765  +
          766  +      #
          767  +      # HACK: For backward compatibility with the results generated by
          768  +      #       the [compileViaCSharpCodeProvider] procedure, we must now
          769  +      #       set the results to an obviously fake opaque object handle
          770  +      #       that still matches the normal pattern.
          771  +      #
          772  +      set results System#CodeDom#Compiler#CompilerResults#0
          773  +
          774  +      #
          775  +      # NOTE: It is assumed that no assembly was generated if there were
          776  +      #       any compiler errors.  Ignore all compiler warnings unless
          777  +      #       we are in strict mode.
          778  +      #
          779  +      if {[llength $errors] > 0 || \
          780  +          ($strict && [llength $warnings] > 0)} then {
          781  +        #
          782  +        # NOTE: Compilation of the assembly failed.
          783  +        #
          784  +        set code Error
          785  +
          786  +        #
          787  +        # NOTE: Prepare to transfer error messages to the caller.
          788  +        #
          789  +        if {[string length $errorsVarName] > 0} then {
          790  +          upvar 1 $errorsVarName local_errors
          791  +        }
          792  +
          793  +        #
          794  +        # NOTE: If there are compiler errors, add them to the list now.
          795  +        #
          796  +        if {[llength $errors] > 0} then {
          797  +          eval lappend local_errors $errors
          798  +        }
          799  +
          800  +        #
          801  +        # NOTE: If there are compiler warnings, add them to the list now.
          802  +        #
          803  +        if {[llength $warnings] > 0} then {
          804  +          eval lappend local_errors $warnings
          805  +        }
          806  +      } else {
          807  +        #
          808  +        # NOTE: If the generated assembly was supposed to be loaded into
          809  +        #       memory, try to do that now.
          810  +        #
          811  +        if {$memory} then {
          812  +          object load -loadtype File $outputFileName
          813  +        }
          814  +
          815  +        #
          816  +        # NOTE: Compilation of the assembly succeeded.
          817  +        #
          818  +        set code Ok
          819  +      }
          820  +    } finally {
          821  +      #
          822  +      # NOTE: Delete the temporary file name used to hold the source code.
          823  +      #
          824  +      if {[string length $sourceFileName] > 0 && \
          825  +          [file exists $sourceFileName]} then {
          826  +        catch {file delete $sourceFileName}
          827  +      }
          828  +    }
          829  +
          830  +    #
          831  +    # HACK: *BREAKING CHANGE* If there is an output file name, return it
          832  +    #       as well; otherwise, just return success.
   239    833       #
   240         -    return $code
          834  +    if {!$memory && [string length $outputFileName] > 0} then {
          835  +      #
          836  +      # NOTE: Return a two element list: the first element is the overall
          837  +      #       result and the second element is the output file name.
          838  +      #
          839  +      return [list $code $outputFileName]
          840  +    } else {
          841  +      #
          842  +      # NOTE: Return the overall result to the caller.
          843  +      #
          844  +      return $code
          845  +    }
          846  +  }
          847  +
          848  +  #
          849  +  # NOTE: This procedure is used to dynamically compile arbitrary C# code
          850  +  #       from within a script.  This procedure was originally designed to
          851  +  #       be used by the test suite; however, it can be quite useful in
          852  +  #       non-test scripts as well.
          853  +  #
          854  +  proc compileCSharp {
          855  +          string memory symbols strict resultsVarName errorsVarName args } {
          856  +    if {[isDotNetCore]} then {
          857  +      return [uplevel 1 [list \
          858  +          compileViaDotNetCoreCSharp $string $memory $symbols $strict \
          859  +          $resultsVarName $errorsVarName] $args]
          860  +    } else {
          861  +      return [uplevel 1 [list \
          862  +          compileViaCSharpCodeProvider $string $memory $symbols $strict \
          863  +          $resultsVarName $errorsVarName] $args]
          864  +    }
   241    865     }
   242    866   
   243    867     #
   244    868     # NOTE: Provide the Eagle "C#" package to the interpreter.
   245    869     #
   246    870     package provide Eagle.CSharp \
   247    871       [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
   248    872   }
   249    873   

Changes to Externals/Eagle/lib/Eagle1.0/exec.eagle.

    50     50         #
    51     51         # HACK: Assume that Mono is somewhere along the PATH.
    52     52         #
    53     53         lappend command mono \
    54     54             [appendArgs \" [file nativename [info nameofexecutable]] \"]
    55     55       } else {
    56     56         lappend command [info nameofexecutable]
           57  +
           58  +      #
           59  +      # HACK: When running on .NET Core, we need to insert the "exec"
           60  +      #       command line argument followed by our assembly name.
           61  +      #
           62  +      if {[isEagle] && [isDotNetCore]} then {
           63  +        lappend command exec
           64  +
           65  +        lappend command [appendArgs \" \
           66  +            [file nativename [lindex [info assembly true] 1]] \"]
           67  +      }
    57     68       }
    58     69   
    59     70       #
    60     71       # NOTE: If possible, check if the current interpreter has security
    61     72       #       enabled; if so, add the appropriate command line option for
    62     73       #       the sub-process.
    63     74       #

Changes to Externals/Eagle/lib/Eagle1.0/info.eagle.

    79     79         if {[regexp -- $pattern [lindex $loaded end]]} then {
    80     80           return [lindex $loaded 0]
    81     81         }
    82     82       }
    83     83   
    84     84       return ""
    85     85     }
           86  +
           87  +  #
           88  +  # NOTE: This procedure returns the fully qualified directory name where new
           89  +  #       packages targeting the interpreter should be installed.  The return
           90  +  #       values of this procedure are subject to change in future releases.
           91  +  #
           92  +  proc getPackageInstallPath { {packageName ""} {temporaryPrefix ""} } {
           93  +    #
           94  +    # NOTE: Skip using the Tcl library location if that has been explicitly
           95  +    #       forbidden.
           96  +    #
           97  +    if {![info exists ::no(getPackageInstallPath)]} then {
           98  +      #
           99  +      # NOTE: First, check if the Tcl library variable exists and its location
          100  +      #       exists.  The location may refer to a file.
          101  +      #
          102  +      global tcl_library
          103  +
          104  +      if {[info exists tcl_library]} then {
          105  +        #
          106  +        # NOTE: What is the parent directory for the Tcl library location?  If
          107  +        #       the Tcl library location was a file, it should be a directory;
          108  +        #       if it was already a directory, it should still be one.  Either
          109  +        #       way, the new (directory) location must be writable.
          110  +        #
          111  +        set directory [file dirname $tcl_library]
          112  +
          113  +        if {[file exists $directory] && [file isdirectory $directory] && \
          114  +            [file writable $directory]} then {
          115  +          #
          116  +          # NOTE: Ok, all checks passed, return the location.  Callers of this
          117  +          #       procedure should generally not put files directly within it;
          118  +          #       instead, they should create a sub-directory within it, named
          119  +          #       appropriately.  If a package name was supplied by the caller
          120  +          #       it will be used.  In that case, the resulting directory will
          121  +          #       be created if necessary.
          122  +          #
          123  +          if {[string length $packageName] > 0} then {
          124  +            set directory [file join $directory $packageName]
          125  +            file mkdir $directory
          126  +          }
          127  +
          128  +          return $directory
          129  +        }
          130  +      }
          131  +    }
          132  +
          133  +    #
          134  +    # NOTE: Next, since the fallback location requires the test package, load
          135  +    #       it now.
          136  +    #
          137  +    package require Eagle.Test
          138  +
          139  +    #
          140  +    # NOTE: Return the temporary directory as the fallback location.  Callers
          141  +    #       of this procedure should generally not put files directly within
          142  +    #       it; instead, they should create a sub-directory within it, named
          143  +    #       appropriately.  If a temporary prefix was supplied by the caller
          144  +    #       it will be used.  In that case, the resulting directory will be
          145  +    #       created if necessary.
          146  +    #
          147  +    set directory [getTemporaryPath]
          148  +
          149  +    if {[string length $temporaryPrefix] > 0} then {
          150  +      set directory [file join \
          151  +          $directory [appendArgs $temporaryPrefix - \
          152  +          [pid] - [string trim [clock seconds] -]]]
          153  +
          154  +      file mkdir $directory
          155  +    }
          156  +
          157  +    return $directory
          158  +  }
    86    159   
    87    160     #
    88    161     # NOTE: This procedure returns the Eagle core library base path, e.g. a
    89    162     #       value like "C:\Eagle" when loaded from "C:\Eagle\bin\Eagle.dll".
    90    163     #
    91    164     proc getBasePath {} {
    92    165       set assembly [object invoke -flags +NonPublic \

Changes to Externals/Eagle/lib/Eagle1.0/init.eagle.

   109    109       }
   110    110   
   111    111       #
   112    112       # NOTE: Success, return an empty string.
   113    113       #
   114    114       return ""
   115    115     }
          116  +
          117  +  #
          118  +  # NOTE: This procedure is designed to "load" (i.e. [source]) other script
          119  +  #       files that logically belong to the package defined in this script
          120  +  #       file.  Upon success, an empty string will be returned.  A script
          121  +  #       error may be raised.  This should work properly in both Tcl and
          122  +  #       Eagle.  This procedure must be defined in this script file because
          123  +  #       it is needed while this script file is being evaluated.  If there
          124  +  #       exists a global array element no($fileNameOnly) corresponding to a
          125  +  #       particular script file to be loaded, it will be skipped.
          126  +  #
          127  +  # <bootstrap>
          128  +  proc maybeLoadScripts { directory fileNamesOnly } {
          129  +    set matchFileNames [list]
          130  +
          131  +    foreach fileNameOnly $fileNamesOnly {
          132  +      if {![info exists ::no($fileNameOnly)]} then {
          133  +        lappend matchFileNames $fileNameOnly
          134  +      }
          135  +    }
          136  +
          137  +    return [uplevel 1 [list loadScripts $directory $matchFileNames]]
          138  +  }
   116    139   
   117    140     if {![interp issafe]} then {
   118    141       #
   119    142       # NOTE: Load the extra script library files that contain commonly used
   120    143       #       procedures that are shared between native Tcl and Eagle.
   121    144       #
   122         -    loadScripts [file dirname [info script]] [list \
          145  +    maybeLoadScripts [file dirname [info script]] [list \
   123    146           auxiliary.eagle database.eagle exec.eagle file1.eagle \
   124    147           file2.eagle file3.eagle info.eagle list.eagle \
   125    148           pkgt.eagle platform.eagle testlog.eagle unzip.eagle]
   126    149   
   127    150       #
   128    151       # NOTE: Load the extra script library files that contain procedures that
   129    152       #       require a specific language (i.e. either native Tcl or Eagle).
   130    153       #
   131    154       if {[isEagle]} then {
   132         -      loadScripts [file dirname [info script]] [list \
          155  +      maybeLoadScripts [file dirname [info script]] [list \
   133    156             compat.eagle csharp.eagle object.eagle process.eagle \
   134    157             runopt.eagle unkobj.eagle update.eagle]
   135    158       } else {
   136         -      loadScripts [file dirname [info script]] [list shim.eagle]
          159  +      maybeLoadScripts [file dirname [info script]] [list shim.eagle]
   137    160       }
   138    161     }
   139    162   
   140    163     if {[isEagle]} then {
   141    164       ###########################################################################
   142    165       ############################ BEGIN Eagle ONLY #############################
   143    166       ###########################################################################
................................................................................
   318    341         }
   319    342       }
   320    343   
   321    344       #
   322    345       # NOTE: Add script library files borrowed from native Tcl.
   323    346       #
   324    347       if {![interp issafe]} then {
   325         -      loadScripts [file dirname [info script]] [list word.tcl]
          348  +      maybeLoadScripts [file dirname [info script]] [list word.tcl]
   326    349       }
   327    350   
   328    351       ###########################################################################
   329    352       ############################# END Eagle ONLY ##############################
   330    353       ###########################################################################
   331    354     } else {
   332    355       ###########################################################################
................................................................................
   335    358   
   336    359       #
   337    360       # NOTE: Exports the necessary commands from this package and import them
   338    361       #       into the global namespace.
   339    362       #
   340    363       if {[llength [info commands exportAndImportPackageCommands]] > 0} then {
   341    364         exportAndImportPackageCommands [namespace current] [list \
   342         -          isEagle loadScripts isWindows isInteractive haveGaruda \
   343         -          isTclThread isMono isSameFileName getEnvironmentVariable \
   344         -          combineFlags getCompileInfo getPlatformInfo getPluginName \
   345         -          getPluginPath appendArgs lappendArgs getDictionaryValue \
   346         -          getColumnValue getRowColumnValue tqputs tqlog \
   347         -          makeBinaryChannel makeAsciiChannel makeUnicodeChannel \
          365  +          isEagle loadScripts maybeLoadScripts isWindows isInteractive \
          366  +          haveGaruda isTclThread isMono isDotNetCore isSameFileName \
          367  +          getEnvironmentVariable combineFlags getCompileInfo getPlatformInfo \
          368  +          getPluginName getPluginPath getPackageInstallPath appendArgs \
          369  +          lappendArgs getDictionaryValue getColumnValue getRowColumnValue \
          370  +          tqputs tqlog makeBinaryChannel makeAsciiChannel makeUnicodeChannel \
   348    371             makeLogChannel readFile readSharedFile writeFile appendFile \
   349    372             appendLogFile appendSharedFile appendSharedLogFile \
   350    373             readAsciiFile writeAsciiFile readUnicodeFile \
   351    374             writeUnicodeFile getDirResultPath addToPath removeFromPath \
   352    375             execShell lshuffle ldifference filter map reduce \
   353    376             getLengthModifier debug findDirectories \
   354    377             findDirectoriesRecursive findFiles findFilesRecursive \

Changes to Externals/Eagle/lib/Eagle1.0/object.eagle.

   129    129         return ""
   130    130       }
   131    131   
   132    132       if {[string length $typeName] == 0} then {
   133    133         return ""
   134    134       }
   135    135   
   136         -    set type [object invoke -create -alias Type GetType $typeName]
          136  +    set type [object invoke -create -alias Utility GetType $typeName]
   137    137   
   138    138       if {[string length $type] == 0} then {
   139    139         return ""
   140    140       }
   141    141   
   142    142       return [expr {[$type IsValueType] ? 0 : "null"}]
   143    143     }
................................................................................
   275    275       #
   276    276       # NOTE: Is there a script to be evaluated when the asynchronous script
   277    277       #       evaluation is complete?  If so, build an anonymous procedure
   278    278       #       that wraps it; otherwise, set the callback argument to null, so
   279    279       #       the core marshaller will handle the lack of a callback correctly.
   280    280       #       The context argument will be added to this script prior to it
   281    281       #       being evaluated; however, it is not actually used by this script.
          282  +    #       The -identifier option is NOT actually processed by the library;
          283  +    #       however, it is necessary here to avoid having multiple calls to
          284  +    #       this procedure collide with each other when attempting to remove
          285  +    #       their callbacks during cleanup.
   282    286       #
   283    287       if {[string length $doneScript] > 0} then {
   284         -      set callback [list -callbackflags {+ResetCancel FireAndForget} \
   285         -          -- apply [list [list script context] {uplevel 1 $script}] \
   286         -          $doneScript]
          288  +      #
          289  +      # NOTE: If the core library was compiled without dynamic delegates,
          290  +      #       this procedure cannot be used when there is a callback, due
          291  +      #       to the AsynchronousCallback delegate type being unsupported.
          292  +      #
          293  +      if {[lsearch -exact -- \
          294  +          $::eagle_platform(compileOptions) EMIT] == -1} then {
          295  +        error "cannot eval async: library missing EMIT compile-option"
          296  +      }
          297  +
          298  +      set callback [list -identifier [expr {random()}] -callbackflags \
          299  +          {+ResetCancel FireAndForget} -- apply [list [list script context] \
          300  +          {uplevel 1 $script}] $doneScript]
   287    301       } else {
   288    302         set callback null
   289    303       }
   290    304   
   291    305       #
   292    306       # NOTE: Initialize the local variable that will be used to receive the
   293    307       #       script error, if any.

Changes to Externals/Eagle/lib/Eagle1.0/pkgt.eagle.

    34     34       # NOTE: The base URI used to build the URIs for the Package Client
    35     35       #       Toolset downloads.
    36     36       #
    37     37       variable baseUri; # DEFAULT: [getAuxiliaryBaseUri] -OR- https://urn.to/r
    38     38   
    39     39       if {$force || ![info exists baseUri]} then {
    40     40         if {[isEagle]} then {
    41         -        package require Eagle.Update
    42     41           set baseUri [getAuxiliaryBaseUri]
    43     42         } else {
    44     43           set baseUri https://urn.to/r
    45     44         }
    46     45       }
    47     46   
    48     47       #
................................................................................
   118    117       # NOTE: The URI where license certificate requests should be sent.
   119    118       #
   120    119       variable licenseUri; # DEFAULT: ${baseUri}/${urn}
   121    120   
   122    121       if {$force || ![info exists licenseUri]} then {
   123    122         set licenseUri {${baseUri}/${urn}}
   124    123       }
          124  +
          125  +    #
          126  +    # NOTE: The URN, relative to the base URI, where script evaluation
          127  +    #       requests should be submitted to the "safe" sandbox.
          128  +    #
          129  +    variable sandboxEvalUrn; # DEFAULT: eval_01
          130  +
          131  +    if {$force || ![info exists sandboxEvalUrn]} then {
          132  +      set sandboxEvalUrn eval_01
          133  +    }
          134  +
          135  +    #
          136  +    # NOTE: The URI where script evaluation requests should be submitted
          137  +    #       to the "safe" sandbox.
          138  +    #
          139  +    variable sandboxEvalUri; # DEFAULT: ${baseUri}/${urn}
          140  +
          141  +    if {$force || ![info exists sandboxEvalUri]} then {
          142  +      set sandboxEvalUri {${baseUri}/${urn}}
          143  +    }
   125    144     }
   126    145   
   127    146     #
   128    147     # NOTE: This procedure attempts to download and extract the Package Client
   129    148     #       Toolset.  The optional channel argument is the output channel where
   130    149     #       diagnostic information is sent.  The optional quiet argument should
   131    150     #       be non-zero to prevent diagnostic information from being emitted.
................................................................................
   139    158       variable baseUri
   140    159       variable packageToolsetUri
   141    160       variable packageToolsetUrn
   142    161   
   143    162       package require Eagle.Test
   144    163       package require Eagle.Unzip
   145    164   
   146         -    set extractRootDirectory [getTemporaryPath]
   147         -
   148         -    set directory [file join $extractRootDirectory [appendArgs \
   149         -        ea-pt-di- [pid] - [string trim [clock seconds] -]]]
          165  +    set extractRootDirectory [getPackageInstallPath pkgd ea-pt-di]
   150    166   
   151    167       set uri [subst $packageToolsetUri]
   152    168       set fileName [getTemporaryFileName]
   153    169   
   154    170       if {[isEagle]} then {
   155    171         uri download $uri $fileName
   156    172       } else {
................................................................................
   161    177             ::Eagle::Tools::Common::writeFile
   162    178   
   163    179         set data [getFileViaHttp $uri 20 $channel $quiet -binary true]
   164    180   
   165    181         writeFile $fileName $data
   166    182       }
   167    183   
   168         -    set extractDirectory [extractZipArchive $fileName $extractRootDirectory]
          184  +    set extractDirectory [extractZipArchive \
          185  +        $fileName $extractRootDirectory true]
          186  +
   169    187       return [file join $extractDirectory pkgr_an_d client 1.0 neutral]
   170    188     }
          189  +
          190  +  #
          191  +  # NOTE: This procedure attempts to load (via [package require]) the package
          192  +  #       client toolset.  It is designed to be used in conjunction with the
          193  +  #       [downloadAndExtractPackageClientToolset] procedure, above.  Support
          194  +  #       is included for specifying an extra auto-path directory and API key
          195  +  #       to use.  By default, the [package unknown] handler is hooked to add
          196  +  #       the remote package repository lookup functionality.  Eagle supports
          197  +  #       extra script security via signed script certificates, which will be
          198  +  #       enabled by default, unless it is unavailable.
          199  +  #
          200  +  proc loadPackageClientToolset {
          201  +          {directory auto} {apiKeys ""} {hookUnknown true} {enableSecurity true}
          202  +          {strictSecurity false} {debug false} } {
          203  +    #
          204  +    # NOTE: When running in Eagle, namespace support must be available and
          205  +    #       enabled.
          206  +    #
          207  +    if {[isEagle] && ![namespace enable]} then {
          208  +      error "namespace support must be enabled"
          209  +    }
          210  +
          211  +    #
          212  +    # NOTE: Does the caller want automatic discovery of the directory that
          213  +    #       contains the (downloaded?) package client toolset?  Currently,
          214  +    #       this only works on Windows and searches the temporary download
          215  +    #       location, which normally obtains its value from the environment
          216  +    #       variable TEMP.
          217  +    #
          218  +    if {$directory eq "auto"} then {
          219  +      #
          220  +      # NOTE: First, before doing anything else, see if the package client
          221  +      #       toolset is already installed somewhere it can be loaded from.
          222  +      #
          223  +      set needDirectory true
          224  +
          225  +      if {[isEagle]} then {
          226  +        #
          227  +        # NOTE: Force Eagle to find *ALL* available package index files.
          228  +        #       This must be done in the global scope so that the special
          229  +        #       global variable 'dir' set by the package index loading
          230  +        #       subsystem can be accessed.  Use [catch] here just in case
          231  +        #       a package index file raises a script error.
          232  +        #
          233  +        catch {
          234  +          uplevel #0 [list package scan -host -normal -refresh]
          235  +        }
          236  +      } else {
          237  +        #
          238  +        # HACK: Force Tcl to find *ALL* available package index files.
          239  +        #       Without this, checking for the available versions of a
          240  +        #       package using [package versions] likely will not succeed
          241  +        #       unless the package is already loaded.  Use [catch] here
          242  +        #       just in case a package index file raises a script error.
          243  +        #
          244  +        catch {
          245  +          package require [appendArgs \
          246  +              bogus_package_ [string trim [clock seconds] -]]
          247  +        }
          248  +      }
          249  +
          250  +      #
          251  +      # NOTE: Check and see if the package repository client is a known
          252  +      #       package now.  If so, there is no need to search directories
          253  +      #       for it.
          254  +      #
          255  +      if {[llength [package versions Eagle.Package.Repository]] > 0} then {
          256  +        set needDirectory false
          257  +      }
          258  +
          259  +      #
          260  +      # NOTE: Is searching for temporary download directories required at
          261  +      #       this point?
          262  +      #
          263  +      if {$needDirectory} then {
          264  +        if {![isWindows]} then {
          265  +          error "directory discovery not supported on this platform"
          266  +        }
          267  +
          268  +        set extractRootDirectory [getPackageInstallPath]
          269  +
          270  +        foreach directory [findDirectoriesRecursive \
          271  +            [file join $extractRootDirectory pkgr_an_d]] {
          272  +          #
          273  +          # NOTE: Reset directory we just found to include the necessary
          274  +          #       sub-directory components for the actual client files
          275  +          #       and then stop, thereby selecting the first match.
          276  +          #
          277  +          set directory [file join $directory client 1.0 neutral]; break
          278  +        }
          279  +      }
          280  +
          281  +      #
          282  +      # NOTE: If no directory was found, just clear the directory name,
          283  +      #       which will cause auto-path modification(s) to be skipped.
          284  +      #
          285  +      if {$directory eq "auto"} then {
          286  +        set directory ""
          287  +      }
          288  +    }
          289  +
          290  +    #
          291  +    # NOTE: If there is a directory specified by the caller -OR- found
          292  +    #       via automatic directory discovery, add it to the auto-path
          293  +    #       now.
          294  +    #
          295  +    if {[string length $directory] > 0} then {
          296  +      #
          297  +      # NOTE: Only modify the auto-path if the directory is not already
          298  +      #       present.  This prevents needless variable trace execution
          299  +      #       that rescans the various auto-path directories.
          300  +      #
          301  +      if {![info exists ::auto_path] || \
          302  +          [lsearch -exact $::auto_path $directory] == -1} then {
          303  +        lappend ::auto_path $directory
          304  +      }
          305  +    }
          306  +
          307  +    #
          308  +    # NOTE: If the caller wants to enable extra diagnostic information,
          309  +    #       set the appropriate environment variables now.
          310  +    #
          311  +    if {$debug} then {
          312  +      set ::env(DEBUG_PKGR) 1; set ::env(DEBUG_PKGD) 1
          313  +    }
          314  +
          315  +    #
          316  +    # NOTE: If the caller specified API keys, add them to the configured
          317  +    #       list of API keys for the package repository client now.  This
          318  +    #       uses a special global variable.
          319  +    #
          320  +    if {[llength $apiKeys] > 0} then {
          321  +      eval lappend ::pkgr_api_keys $apiKeys
          322  +    }
          323  +
          324  +    #
          325  +    # NOTE: If the caller wants to enable the extra Eagle script security,
          326  +    #       attempt to do that now.  Only treat a failure here as fatal if
          327  +    #       the caller said so.
          328  +    #
          329  +    if {[isEagle] && $enableSecurity} then {
          330  +      if {[catch {
          331  +        uplevel 1 [list source enableSecurity]
          332  +      } error] && $strictSecurity} then {
          333  +        error $error
          334  +      }
          335  +    }
          336  +
          337  +    #
          338  +    # NOTE: In Eagle, to actually enable make use of the [package unknown]
          339  +    #       handler, an interpreter flag must be disabled.  If necessary,
          340  +    #       do that now.
          341  +    #
          342  +    if {[isEagle] && $hookUnknown} then {
          343  +      object invoke -flags +NonPublic -objectflags +AutoFlagsEnum \
          344  +          Interpreter.GetActive interpreterFlags -NoPackageUnknown
          345  +    }
          346  +
          347  +    #
          348  +    # NOTE: Finally, attempt to actually load the package repository client.
          349  +    #       This may fail for a number of reasons.  The most likely failure
          350  +    #       case is when the directory containing the package is not found;
          351  +    #       however, there are other possible failure modes.
          352  +    #
          353  +    package require Eagle.Package.Repository
          354  +  }
   171    355   
   172    356     #
   173    357     # NOTE: This procedure attempts to download and extract a native TclKit DLL
   174    358     #       for the current platform.  The optional channel argument is the
   175    359     #       output channel where diagnostic information is sent.  The optional
   176    360     #       quiet argument should be non-zero to prevent diagnostic information
   177    361     #       from being emitted.  This procedure may raise script errors.  The
................................................................................
   184    368       variable baseUri
   185    369       variable tclKitDllUri
   186    370       variable tclKitDllUrn
   187    371   
   188    372       package require Eagle.Test
   189    373       package require Eagle.Unzip
   190    374   
   191         -    set extractRootDirectory [getTemporaryPath]
   192         -
   193         -    set directory [file join $extractRootDirectory [appendArgs \
   194         -        ea-td-di- [pid] - [string trim [clock seconds] -]]]
   195         -
   196    375       set platform [machineToPlatform $::tcl_platform(machine) true]
          376  +
          377  +    set extractRootDirectory [getPackageInstallPath \
          378  +        [appendArgs KitDll_ $platform] ea-td-di]
          379  +
   197    380       set urn [subst $tclKitDllUrn]; set uri [subst $tclKitDllUri]
   198    381       set fileName [getTemporaryFileName]
   199    382   
   200    383       if {[isEagle]} then {
   201    384         uri download $uri $fileName
   202    385       } else {
   203    386         package require Eagle.Tools.Common
................................................................................
   207    390             ::Eagle::Tools::Common::writeFile
   208    391   
   209    392         set data [getFileViaHttp $uri 20 $channel $quiet -binary true]
   210    393   
   211    394         writeFile $fileName $data
   212    395       }
   213    396   
   214         -    set extractDirectory [extractZipArchive $fileName $extractRootDirectory]
          397  +    set extractDirectory [extractZipArchive \
          398  +        $fileName $extractRootDirectory true]
   215    399   
   216    400       return [lindex [glob -nocomplain \
   217    401           [file join $extractDirectory lib *[info sharedlibextension]]] 0]
   218    402     }
   219    403   
   220    404     #
   221    405     # NOTE: This procedure attempts to download and extract the Security Toolset,
................................................................................
   233    417       variable baseUri
   234    418       variable securityToolsetUri
   235    419       variable securityToolsetUrn
   236    420   
   237    421       package require Eagle.Test
   238    422       package require Eagle.Unzip
   239    423   
   240         -    set extractRootDirectory [getTemporaryPath]
   241         -
   242         -    set directory [file join $extractRootDirectory [appendArgs \
   243         -        ea-st-di- [pid] - [string trim [clock seconds] -]]]
   244         -
   245         -    if {[info exists ::eagle_platform(text)]} then {
          424  +    if {[info exists ::eagle_platform(text)] && \
          425  +        [string length $::eagle_platform(text)] > 0} then {
   246    426         set platform [string tolower $::eagle_platform(text)]
   247    427       } else {
   248    428         set platform [string tolower netFx20]; # TODO: Good default?
   249    429       }
          430  +
          431  +    set extractRootDirectory [getPackageInstallPath \
          432  +        [appendArgs eee_ $platform] ea-st-di]
   250    433   
   251    434       set dir [string map [list fx ""] $platform]; # netfx20 -> net20
   252    435       set urn [subst $securityToolsetUrn]; set uri [subst $securityToolsetUri]
   253    436       set fileName [getTemporaryFileName]
   254    437   
   255    438       if {[isEagle]} then {
   256    439         uri download $uri $fileName
................................................................................
   262    445             ::Eagle::Tools::Common::writeFile
   263    446   
   264    447         set data [getFileViaHttp $uri 20 $channel $quiet -binary true]
   265    448   
   266    449         writeFile $fileName $data
   267    450       }
   268    451   
   269         -    set extractDirectory [extractZipArchive $fileName $extractRootDirectory]
          452  +    set extractDirectory [extractZipArchive \
          453  +        $fileName $extractRootDirectory true]
          454  +
   270    455       return [file join $extractDirectory build $dir lib]
   271    456     }
   272    457   
   273    458     #
   274    459     # NOTE: This procedure attempts to request a license certificate for Eagle,
   275    460     #       which includes the Harpy and Badge plugins.  The optional channel
   276    461     #       argument is the output channel where diagnostic information is sent.
................................................................................
   443    628       set newFileName [file join $directory [file tail $fileName]]
   444    629   
   445    630       file mkdir $directory; file copy $fileName $newFileName
   446    631       file delete $fileName
   447    632   
   448    633       return $newFileName
   449    634     }
          635  +
          636  +  #
          637  +  # NOTE: This procedure attempts to submit the specified script to a remote
          638  +  #       sandbox for evaluation.  The apiKey parameter is the optional API
          639  +  #       key to use, which MAY enable additional permissions in the remote
          640  +  #       sandbox.  The params parameter contains any optional extra names
          641  +  #       and values to include in the submitted query.  Upon success, this
          642  +  #       procedure returns a Tcl dictionary that includes at least the keys
          643  +  #       "returnCode", "result", and "errorLine".  The "returnCode" value
          644  +  #       will be "Ok", "Error", "Return", "Break", "Continue", or possibly
          645  +  #       a signed integer.  The "result" value will be the textual result
          646  +  #       of the script or an error message.  The "errorLine" value will be
          647  +  #       zero or the line where a script error was raised.  This procedure
          648  +  #       may raise script errors.
          649  +  #
          650  +  proc evaluateInRemoteSandbox {
          651  +          script {apiKey ""} {params ""} {channel stdout} {quiet false} } {
          652  +    setupPackageToolsetVars false
          653  +
          654  +    variable baseUri
          655  +    variable sandboxEvalUri
          656  +    variable sandboxEvalUrn
          657  +
          658  +    set urn [subst $sandboxEvalUrn]
          659  +    set uri [subst $sandboxEvalUri]
          660  +
          661  +    set query [list go 1 raw 1 script $script]
          662  +
          663  +    if {[string length $apiKey] > 0} then {
          664  +      lappend query apiKey $apiKey
          665  +    }
          666  +
          667  +    if {[llength $params] > 0} then {
          668  +      eval lappend query $params
          669  +    }
          670  +
          671  +    if {[isEagle]} then {
          672  +      return [uri upload -inline -data $query $uri]
          673  +    } else {
          674  +      package require http 2.0
          675  +      package require Eagle.Tools.Common
          676  +
          677  +      namespace import \
          678  +          ::Eagle::Tools::Common::getFileViaHttp
          679  +
          680  +      return [getFileViaHttp \
          681  +          $uri 20 $channel $quiet -binary true \
          682  +          -query [eval ::http::formatQuery $query]]
          683  +    }
          684  +  }
   450    685   
   451    686     #
   452    687     # NOTE: Provide the Eagle "package toolset" package to the interpreter.
   453    688     #
   454    689     package provide Eagle.Package.Toolset \
   455    690       [expr {[isEagle] ? [info engine PatchLevel] : "1.0"}]
   456    691   }
   457    692   

Changes to Externals/Eagle/lib/Eagle1.0/platform.eagle.

    35     35       #
    36     36       return [expr {[info exists ::tcl_platform(engine)] && \
    37     37           [string compare -nocase eagle $::tcl_platform(engine)] == 0}]
    38     38     }
    39     39   
    40     40     #
    41     41     # NOTE: This is the procedure that detects whether or not we are running
    42         -  #       in Eagle on Mono (otherwise, we are running in Tcl or in Eagle on
    43         -  #       the .NET Framework).  This procedure must function correctly in
    44         -  #       both Tcl and Eagle and must return non-zero only when running in
    45         -  #       Eagle on Mono.
           42  +  #       in Eagle on Mono (i.e. otherwise, we are running in Tcl or in Eagle
           43  +  #       on the .NET Framework or .NET Core).  This procedure must function
           44  +  #       correctly in both Tcl and Eagle and must return non-zero only when
           45  +  #       running in Eagle on Mono.
    46     46     #
    47     47     proc isMono {} {
    48     48       #
    49     49       # NOTE: Nothing too fancy or expensive should be done here.  In theory,
    50     50       #       use of this procedure should be rare; however, in practice, this
    51     51       #       procedure is actually used quite a bit (e.g. by the test suite).
    52     52       #
    53     53       return [expr {[info exists ::eagle_platform(runtime)] && \
    54     54           [string compare -nocase mono $::eagle_platform(runtime)] == 0}]
    55     55     }
           56  +
           57  +  #
           58  +  # NOTE: This is the procedure that detects whether or not we are running
           59  +  #       in Eagle on .NET Core (i.e. otherwise, we are running in Tcl or in
           60  +  #       Eagle on the .NET Framework or Mono).  This procedure must function
           61  +  #       correctly in both Tcl and Eagle and must return non-zero only when
           62  +  #       running in Eagle on .NET Core.
           63  +  #
           64  +  proc isDotNetCore {} {
           65  +    #
           66  +    # NOTE: Nothing too fancy or expensive should be done here.  In theory,
           67  +    #       use of this procedure should be rare; however, in practice, this
           68  +    #       procedure is actually used quite a bit (e.g. by the test suite).
           69  +    #
           70  +    return [expr {[info exists ::eagle_platform(runtime)] && \
           71  +        [string compare -nocase ".net core" $::eagle_platform(runtime)] == 0}]
           72  +  }
    56     73   
    57     74     #
    58     75     # NOTE: This procedure returns non-zero if the logged on user has full
    59     76     #       administrator rights on this machine.  Currently, this only works
    60     77     #       in Eagle; however, it may work from native Tcl in the future.
    61     78     #
    62     79     proc isAdministrator {} {

Changes to Externals/Eagle/lib/Eagle1.0/test.eagle.

   286    286   
   287    287       foreach name [eval $command] {
   288    288         lappend result $name $array($name)
   289    289       }
   290    290   
   291    291       return $result
   292    292     }
          293  +
          294  +  proc testArrayGet2 { varName {pattern ""} {integer false} } {
          295  +    #
          296  +    # NOTE: Returns the results of [array get] in a well-defined order.
          297  +    #
          298  +    if {[string length $varName] == 0} then {
          299  +      return [list]
          300  +    }
          301  +
          302  +    #
          303  +    # NOTE: Refer to the array in the context of the caller.
          304  +    #
          305  +    upvar 1 $varName array
          306  +
          307  +    #
          308  +    # NOTE: Build the command that will sort the array names into order.
          309  +    #
          310  +    set command [list lsort]
          311  +    if {$integer} then {lappend command -integer}
          312  +
          313  +    #
          314  +    # NOTE: If there is a pattern, use it; otherwise, all elements are
          315  +    #       returned.
          316  +    #
          317  +    if {[string length $pattern] > 0} then {
          318  +      lappend command [array names array $pattern]
          319  +    } else {
          320  +      lappend command [array names array]
          321  +    }
          322  +
          323  +    set result [list]
          324  +
          325  +    foreach name [eval $command] {
          326  +      lappend result $name $array($name)
          327  +    }
          328  +
          329  +    return $result
          330  +  }
   293    331   
   294    332     proc testResultGet { script } {
   295    333       set code [catch {uplevel 1 $script} result]
   296    334       return [expr {$code == 0 ? $result : "<error>"}]
   297    335     }
   298    336   
   299    337     proc testValueGet { varName {integer false} } {
................................................................................
   714    752       #
   715    753       # NOTE: Return the nested list of unknown arguments, formatted as
   716    754       #       name/value pairs, to the caller.
   717    755       #
   718    756       return $result
   719    757     }
   720    758   
   721         -  proc getTclShellFileName { automatic kits } {
          759  +  proc getTclShellFileName { automatic kits machine } {
   722    760       #
   723    761       # NOTE: Start out with an empty list of candiate Tcl shells.
   724    762       #
   725    763       set shells [list]
   726    764   
   727    765       #
   728         -    # NOTE: Check all environment variables we know about that
          766  +    # NOTE: Figure out the environment variables to be checked.  If
          767  +    #       there was a machine specified, it will be used to check
          768  +    #       for machine-specific Tcl shells.
          769  +    #
          770  +    set names [list]
          771  +
          772  +    foreach name [list Eagle_Tcl_Shell Tcl_Shell EAGLE_TCLSH TCLSH] {
          773  +      if {[string length $machine] > 0} then {
          774  +        set platform [machineToPlatform $machine true]
          775  +
          776  +        if {[string length $platform] > 0} then {
          777  +          lappend names [appendArgs $name _ $platform]
          778  +        }
          779  +
          780  +        set platform [machineToPlatform $machine false]
          781  +
          782  +        if {[string length $platform] > 0} then {
          783  +          lappend names [appendArgs $name _ $platform]
          784  +        }
          785  +
          786  +        lappend names [appendArgs $name _ $machine]
          787  +      }
          788  +
          789  +      lappend names $name
          790  +    }
          791  +
          792  +    #
          793  +    # NOTE: Check all environment variables (we know about) that
   729    794       #       may contain the path where the Tcl shell is located.
   730    795       #
   731         -    foreach name [list Eagle_Tcl_Shell Tcl_Shell EAGLE_TCLSH TCLSH] {
          796  +    foreach name $names {
          797  +      #
          798  +      # NOTE: Grab the value of the environment variable.  This
          799  +      #       will be an empty string if it was not set.
          800  +      #
   732    801         set value [getEnvironmentVariable $name]
   733    802   
   734    803         #
   735    804         # TODO: Possibly add a check if the file actually exists
   736    805         #       here.
   737    806         #
   738    807         if {[string length $value] > 0} then {
................................................................................
  1311   1380         return $::test_flags(-suffix)
  1312   1381       } elseif {[info exists ::test_suffix]} then {
  1313   1382         #
  1314   1383         # NOTE: Use the test suffix.  There is no default value for
  1315   1384         #       this variable (i.e. by default, it does not exist).
  1316   1385         #
  1317   1386         return $::test_suffix
  1318         -    } elseif {[info exists ::eagle_platform(text)]} then {
         1387  +    } elseif {[info exists ::eagle_platform(text)] && \
         1388  +        [string length $::eagle_platform(text)] > 0} then {
  1319   1389         #
  1320         -      # NOTE: Use the build text of Eagle itself.  This value will
  1321         -      #       typically be "NetFx20" or "NetFx40".
         1390  +      # NOTE: Use the build "text" of Eagle itself.  This value
         1391  +      #       will typically be "NetFx20", "NetFx40", etc.  The
         1392  +      #       default value of this element is an empty string.
  1322   1393         #
  1323   1394         return $::eagle_platform(text)
         1395  +    } elseif {[info exists ::eagle_platform(suffix)] && \
         1396  +        [string length $::eagle_platform(suffix)] > 0} then {
         1397  +      #
         1398  +      # NOTE: Use the build suffix of Eagle itself.  This value
         1399  +      #       will typically be "NetFx20", "NetFx40", etc.  The
         1400  +      #       default value of this element is an empty string.
         1401  +      #
         1402  +      return $::eagle_platform(suffix)
  1324   1403       } else {
  1325   1404         #
  1326   1405         # NOTE: We are missing the suffix, return nothing.
  1327   1406         #
  1328   1407         return ""
  1329   1408       }
  1330   1409     }
................................................................................
  1333   1412       if {[info exists ::test_uncounted_leaks] && \
  1334   1413           [string length $::test_uncounted_leaks] > 0} then {
  1335   1414         return $::test_uncounted_leaks
  1336   1415       }
  1337   1416   
  1338   1417       return [list]
  1339   1418     }
         1419  +
         1420  +  proc getRuntimeAssemblyName {} {
         1421  +    if {[isEagle]} then {
         1422  +      if {[isDotNetCore]} then {
         1423  +        if {[llength [info commands object]] > 0} then {
         1424  +          #
         1425  +          # HACK: The core runtime assembly (i.e. the one containing
         1426  +          #       System.Object, et al) must have already been loaded
         1427  +          #       (?), so just abuse the [object load] sub-command to
         1428  +          #       return its assembly name.
         1429  +          #
         1430  +          return [lindex [object load System.Private.CoreLib] 0]
         1431  +        } else {
         1432  +          #
         1433  +          # HACK: The [object] command is unavailable, just fake it.
         1434  +          #
         1435  +          return "System.Private.CoreLib, Version=4.0.0.0,\
         1436  +              Culture=neutral, PublicKeyToken=7cec85d7bea7798e"
         1437  +        }
         1438  +      } else {
         1439  +        if {[llength [info commands object]] > 0} then {
         1440  +          #
         1441  +          # HACK: The core runtime assembly (i.e. the one containing
         1442  +          #       System.Object, et al) must have already been loaded
         1443  +          #       (?), so just abuse the [object load] sub-command to
         1444  +          #       return its assembly name.
         1445  +          #
         1446  +          return [lindex [object load mscorlib] 0]
         1447  +        } else {
         1448  +          #
         1449  +          # HACK: The [object] command is unavailable, just fake it.
         1450  +          #
         1451  +          if {[info exists ::eagle_platform(runtimeVersion)] && \
         1452  +              [string index $::eagle_platform(runtimeVersion) 0] >= 4} then {
         1453  +            #
         1454  +            # BUGBUG: Does not handle a major CLR version greater than
         1455  +            #         four (4).
         1456  +            #
         1457  +            return "mscorlib, Version=4.0.0.0, Culture=neutral,\
         1458  +                PublicKeyToken=b77a5c561934e089"
         1459  +          } else {
         1460  +            return "mscorlib, Version=2.0.0.0, Culture=neutral,\
         1461  +                PublicKeyToken=b77a5c561934e089"
         1462  +          }
         1463  +        }
         1464  +      }
         1465  +    } else {
         1466  +      #
         1467  +      # HACK: Native Tcl has no runtime assembly name as it is native.
         1468  +      #
         1469  +      return ""
         1470  +    }
         1471  +  }
  1340   1472   
  1341   1473     proc getTestAssemblyName {} {
  1342   1474       if {[isEagle]} then {
  1343   1475         return [lindex [split [lindex [info assembly] 0] ,] 0]
  1344   1476       } else {
  1345   1477         return Eagle
  1346   1478       }
................................................................................
  1398   1530       #
  1399   1531       # HACK: Assume that Mono is somewhere along the PATH.
  1400   1532       #
  1401   1533       if {[isMono]} then {
  1402   1534         lappend command mono \
  1403   1535             [appendArgs \" [file nativename $commandName] \"]
  1404   1536       } else {
  1405         -      lappend command $commandName
         1537  +      #
         1538  +      # HACK: When running on .NET Core, need to insert "dotnet exec"
         1539  +      #       command line arguments before command to execute.
         1540  +      #
         1541  +      if {[isDotNetCore]} then {
         1542  +        lappend command dotnet exec \
         1543  +            [appendArgs \" [file nativename $commandName] \"]
         1544  +      } else {
         1545  +        lappend command $commandName
         1546  +      }
  1406   1547       }
  1407   1548   
  1408   1549       if {[llength $args] > 0} then {eval lappend command $args}
  1409   1550       set procName [lindex [info level [info level]] 0]
  1410   1551   
  1411   1552       if {![canTestExec $procName]} then {
  1412   1553         tputs $::test_channel [appendArgs "---- skipping command: " $command \n]
................................................................................
  1597   1738         hookPuts
  1598   1739       }
  1599   1740   
  1600   1741       set code [catch {uplevel 1 $script} result]
  1601   1742       set error [expr {$code == 0 ? false : true}]
  1602   1743   
  1603   1744       if {[isEagle]} then {
         1745  +      #
         1746  +      # NOTE: Initially, the call to [tresult] (i.e. [host result]) will
         1747  +      #       use the actual return code from the test command; however,
         1748  +      #       if that return code was 3 (i.e. break), that indicates the
         1749  +      #       test results should be highlighted in yellow -AND- that the
         1750  +      #       test should still be considered successful even though the
         1751  +      #       test was skipped.  If the return code was 4 (i.e. continue),
         1752  +      #       that indicates the test results should be highlighted in
         1753  +      #       dark yellow -AND- that the test should still be considered
         1754  +      #       successful because failures are being ignored for it.
         1755  +      #
         1756  +      set tresultCode $code
         1757  +
         1758  +      if {$code == 3} then {
         1759  +        set code 0; set error false
         1760  +      } elseif {$code == 4} then {
         1761  +        set code 0
         1762  +      }
         1763  +
         1764  +      #
         1765  +      # NOTE: If the return code from the test command indicates success
         1766  +      #       and the test results contain a clear indication of failure,
         1767  +      #       reset both return codes to indicate that failure.
         1768  +      #
  1604   1769         if {$code == 0 && [regexp -- {\s==== (.*?) FAILED\s} $result]} then {
  1605         -        set code 1
         1770  +        set code 1; set tresultCode $code
  1606   1771         }
  1607   1772   
  1608   1773         #
  1609   1774         # NOTE: Display and/or log the results for the test that we just
  1610   1775         #       completed.
  1611   1776         #
  1612   1777         if {[shouldWriteTestData $code]} then {
  1613         -        tresult $code $result
         1778  +        tresult $tresultCode $result
  1614   1779         } else {
  1615   1780           tlog $result
  1616   1781         }
  1617   1782   
  1618   1783         #
  1619   1784         # NOTE: If the test failed with an actual error (i.e. not just a
  1620   1785         #       test failure), make sure we do not obscure the error
................................................................................
  2030   2195       #
  2031   2196       set map [list \
  2032   2197           \\ \\\\ \$ \\\$ ( \\( ) \\) * \\* + \\+ - \\- . \\. \
  2033   2198           ? \\? \[ \\\[ \] \\\] ^ \\^ \{ \\\{ \} \\\}]
  2034   2199   
  2035   2200       return [string map $map [expr {$list ? [list $path] : $path}]]
  2036   2201     }
         2202  +
         2203  +  proc assemblyNameToRegexp { assemblyName {list false} } {
         2204  +    #
         2205  +    # NOTE: This procedure needs to escape all characters that
         2206  +    #       have any special meaning to the regular expression
         2207  +    #       engine -AND- that can actually appear in a legal
         2208  +    #       assembly name.  Normally, this would only include
         2209  +    #       the period character.
         2210  +    #
         2211  +    # HACK: For now, just abuse the [pathToRegexp] procedure
         2212  +    #       for this.
         2213  +    #
         2214  +    return [pathToRegexp $assemblyName $list]
         2215  +  }
  2037   2216   
  2038   2217     proc inverseLsearchGlob { noCase patterns element } {
  2039   2218       #
  2040   2219       # NOTE: Perform the inverse of [lsearch -glob], attempt
  2041   2220       #       to match an element against a list of patterns.
  2042   2221       #
  2043   2222       set command [list string match]
................................................................................
  2123   2302     proc clearTestPercent { channel } {
  2124   2303       if {[isEagle]} then {
  2125   2304         host title ""
  2126   2305       }
  2127   2306     }
  2128   2307   
  2129   2308     proc reportTestPercent {
  2130         -          channel percent totalFiles failedFiles leakedFiles } {
         2309  +          channel percent doneFiles totalFiles failedFiles leakedFiles } {
  2131   2310       if {[isEagle]} then {
  2132   2311         set totalTests $::eagle_tests(Total)
  2133   2312         set failedTests $::eagle_tests(Failed)
  2134   2313         set skippedTests $::eagle_tests(Skipped)
  2135   2314       } else {
  2136   2315         set totalTests $::tcltest::numTests(Total)
  2137   2316         set failedTests $::tcltest::numTests(Failed)
  2138   2317         set skippedTests $::tcltest::numTests(Skipped)
  2139   2318       }
  2140   2319   
  2141   2320       set status [appendArgs \
  2142   2321           "---- test suite running, about " $percent "% complete (" \
  2143   2322           $totalTests " tests total, " $failedTests " tests failed, " \
  2144         -        $skippedTests " tests skipped, " $totalFiles " files total, " \
  2145         -        $failedFiles " files failed, " $leakedFiles " files leaked)..."]
         2323  +        $skippedTests " tests skipped, " $doneFiles " files done, " \
         2324  +        $totalFiles " files total, " $failedFiles " files failed, " \
         2325  +        $leakedFiles " files leaked)..."]
  2146   2326   
  2147   2327       tputs $channel [appendArgs $status \n]
  2148   2328   
  2149   2329       if {[isEagle]} then {
  2150   2330         host title $status
  2151   2331       }
  2152   2332     }
................................................................................
  2253   2433       #
  2254   2434       set failed [list]
  2255   2435       set leaked [list]
  2256   2436   
  2257   2437       #
  2258   2438       # NOTE: Process each file name we have been given by the caller...
  2259   2439       #
  2260         -    set total 0; set lastPercent -1
         2440  +    set total [llength $fileNames]; set lastPercent -1
  2261   2441   
  2262   2442       foreach fileName $fileNames {
  2263   2443         #
  2264   2444         # NOTE: If configured to break into the debugger before running the
  2265   2445         #       test file, do it now.
  2266   2446         #
  2267   2447         if {[isBreakOnDemand]} then {
................................................................................
  2268   2448           testDebugBreak
  2269   2449         }
  2270   2450   
  2271   2451         #
  2272   2452         # NOTE: In terms of files, not tests, what percent done are we now?
  2273   2453         #
  2274   2454         set percent [formatDecimal \
  2275         -          [expr {$total != 0 ? 100.0 * ($count / double($total)) : 100}]]
         2455  +          [expr {$total != 0 ? 100.0 * ($count / double($total)) : 0}]]
  2276   2456   
  2277   2457         if {$percent != $lastPercent} then {
  2278   2458           if {![info exists ::no(runPercent)]} then {
  2279   2459             reportTestPercent $channel $percent \
  2280         -              $total [llength $failed] [llength $leaked]
         2460  +              $count $total [llength $failed] [llength $leaked]
  2281   2461           }
  2282   2462   
  2283   2463           set lastPercent $percent
  2284   2464         }
  2285   2465   
  2286   2466         #
  2287   2467         # NOTE: If the starting file names have been specified by the caller,
................................................................................
  2442   2622               #
  2443   2623               # NOTE: Log that this test file has ended.
  2444   2624               #
  2445   2625               if {![info exists ::no(runEndFile)]} then {
  2446   2626                 tputs $channel [appendArgs "==== \"" $fileName "\" END\n"]
  2447   2627               }
  2448   2628   
  2449         -            #
  2450         -            # NOTE: At this point, we know that another test file was
  2451         -            #       processed successfully.
  2452         -            #
  2453         -            incr total
  2454         -
  2455         -            if {![info exists ::no(runPercent)]} then {
  2456         -              reportTestPercent $channel $percent \
  2457         -                  $total [llength $failed] [llength $leaked]
  2458         -            }
  2459         -
  2460   2629               #
  2461   2630               # NOTE: Are we being prevented from waiting after the file?
  2462   2631               #
  2463   2632               if {![info exists ::no(postWait)]} then {
  2464   2633                 if {[info exists ::test_wait(post)] && \
  2465   2634                     [string is integer -strict $::test_wait(post)]} then {
  2466   2635                   if {![info exists ::no(runMetadata)]} then {
................................................................................
  2523   2692                 #       the failure.  Set a special variable for the epilogue
  2524   2693                 #       to pick up on (later).
  2525   2694                 #
  2526   2695                 lappend ::test_suite_errors [list $fileName $error]
  2527   2696               }
  2528   2697             }
  2529   2698   
  2530         -          #
  2531         -          # NOTE: We evaluated another test file.
  2532         -          #
  2533         -          incr count
  2534         -
  2535   2699             #
  2536   2700             # NOTE: Record failed test count after this file.
  2537   2701             #
  2538   2702             if {[isEagle]} then {
  2539   2703               set after $::eagle_tests(Failed)
  2540   2704             } else {
  2541   2705               set after $::tcltest::numTests(Failed)
................................................................................
  2548   2712               lappend failed [file tail $fileName]
  2549   2713             }
  2550   2714   
  2551   2715             #
  2552   2716             # NOTE: In terms of files, not tests, what percent done are we now?
  2553   2717             #
  2554   2718             set percent [formatDecimal \
  2555         -              [expr {$total != 0 ? 100.0 * ($count / double($total)) : 100}]]
         2719  +              [expr {$total != 0 ? 100.0 * ($count / double($total)) : 0}]]
  2556   2720   
  2557   2721             if {$percent != $lastPercent} then {
  2558   2722               if {![info exists ::no(runPercent)]} then {
  2559   2723                 reportTestPercent $channel $percent \
  2560         -                  $total [llength $failed] [llength $leaked]
         2724  +                  $count $total [llength $failed] [llength $leaked]
  2561   2725               }
  2562   2726   
  2563   2727               set lastPercent $percent
  2564   2728             }
  2565   2729   
  2566   2730             #
  2567   2731             # NOTE: Unset the current test file name, it is no longer
................................................................................
  2593   2757             #
  2594   2758             if {![info exists ::no(runNonTestFile)]} then {
  2595   2759               tputs $channel [appendArgs \
  2596   2760                   "==== \"" $fileName "\" NON_TEST_FILE\n"]
  2597   2761             }
  2598   2762           }
  2599   2763   
         2764  +        #
         2765  +        # NOTE: Another file of some kind was processed.  It may have been
         2766  +        #       skipped; however, that does not matter.
         2767  +        #
         2768  +        incr count
         2769  +
  2600   2770           #
  2601   2771           # NOTE: In terms of files, not tests, what percent done are we now?
  2602   2772           #
  2603   2773           set percent [formatDecimal \
  2604         -            [expr {$total != 0 ? 100.0 * ($count / double($total)) : 100}]]
         2774  +            [expr {$total != 0 ? 100.0 * ($count / double($total)) : 0}]]
  2605   2775   
  2606   2776           if {$percent != $lastPercent} then {
  2607   2777             if {![info exists ::no(runPercent)]} then {
  2608   2778               reportTestPercent $channel $percent \
  2609         -                $total [llength $failed] [llength $leaked]
         2779  +                $count $total [llength $failed] [llength $leaked]
  2610   2780             }
  2611   2781   
  2612   2782             set lastPercent $percent
  2613   2783           }
  2614   2784   
  2615   2785           #
  2616   2786           # NOTE: If the test file raised an error (i.e. to indicate a
................................................................................
  2624   2794           #
  2625   2795           # NOTE: This entire file has been skipped.  Record that fact in the
  2626   2796           #       test suite log file.
  2627   2797           #
  2628   2798           if {![info exists ::no(runSkippedFile)]} then {
  2629   2799             tputs $channel [appendArgs "==== \"" $fileName "\" SKIPPED\n"]
  2630   2800           }
         2801  +
         2802  +        #
         2803  +        # NOTE: This file was skipped.
         2804  +        #
         2805  +        incr count
  2631   2806         }
  2632   2807   
  2633   2808         #
  2634   2809         # NOTE: In terms of files, not tests, what percent done are we now?
  2635   2810         #
  2636   2811         set percent [formatDecimal \
  2637         -          [expr {$total != 0 ? 100.0 * ($count / double($total)) : 100}]]
         2812  +          [expr {$total != 0 ? 100.0 * ($count / double($total)) : 0}]]
  2638   2813   
  2639   2814         if {$percent != $lastPercent} then {
  2640   2815           if {![info exists ::no(runPercent)]} then {
  2641   2816             reportTestPercent $channel $percent \
  2642         -              $total [llength $failed] [llength $leaked]
         2817  +              $count $total [llength $failed] [llength $leaked]
  2643   2818           }
  2644   2819   
  2645   2820           set lastPercent $percent
  2646   2821         }
  2647   2822       }
  2648   2823   
  2649   2824       #
................................................................................
  3313   3488           return [expr \
  3314   3489               {100.0 * ($::eagle_tests(Skipped) / \
  3315   3490               double($::eagle_tests(Total)))}]
  3316   3491         }
  3317   3492   
  3318   3493         return 0; # no tests were run, etc.
  3319   3494       }
         3495  +
         3496  +    proc createThread { script {parameterized false} {maxStackSize ""} } {
         3497  +      if {[isDotNetCore]} then {
         3498  +        #
         3499  +        # HACK: This seems to make .NET Core happier for reasons
         3500  +        #       that are not entirely clear.
         3501  +        #
         3502  +        set typeName "System.Threading.Thread, mscorlib"
         3503  +      } else {
         3504  +        set typeName System.Threading.Thread
         3505  +      }
         3506  +
         3507  +      if {$parameterized} then {
         3508  +        if {[string length $maxStackSize] > 0} then {
         3509  +          return [object create -alias -objectflags +NoReturnReference \
         3510  +              -parametertypes System.Threading.ParameterizedThreadStart \
         3511  +              $typeName $script $maxStackSize]
         3512  +        } else {
         3513  +          return [object create -alias -objectflags +NoReturnReference \
         3514  +              -parametertypes System.Threading.ParameterizedThreadStart \
         3515  +              $typeName $script]
         3516  +        }
         3517  +      } else {
         3518  +        if {[string length $maxStackSize] > 0} then {
         3519  +          return [object create -alias -objectflags +NoReturnReference \
         3520  +              $typeName $script $maxStackSize]
         3521  +        } else {
         3522  +          return [object create -alias -objectflags +NoReturnReference \
         3523  +              $typeName $script]
         3524  +        }
         3525  +      }
         3526  +    }
         3527  +
         3528  +    proc startThread { thread {parameterized false} {parameter null} } {
         3529  +      if {$parameterized} then {
         3530  +        $thread Start $parameter
         3531  +      } else {
         3532  +        $thread Start
         3533  +      }
         3534  +    }
  3320   3535   
  3321   3536       proc cleanupThread { thread {timeout 2000} } {
  3322   3537         if {[$thread IsAlive]} then {
  3323   3538           if {[catch {$thread Interrupt} error]} then {
  3324   3539             tputs $::test_channel [appendArgs \
  3325   3540                 "---- failed to interrupt test thread \"" $thread "\": " \
  3326   3541                 $error \n]
................................................................................
  3451   3666             "---- StringOps cleanup results: " $result \n]
  3452   3667   
  3453   3668         catch {uplevel 1 [list object invoke -flags +NonPublic \
  3454   3669             Eagle._Comparers.FileName ClearCache]} result
  3455   3670   
  3456   3671         tputs $channel [appendArgs \
  3457   3672             "---- Comparers.FileName cleanup results: " $result \n]
         3673  +
         3674  +      catch {uplevel 1 [list object invoke -flags +NonPublic \
         3675  +          Eagle._Components.Private.HashOps Cleanup]} result
         3676  +
         3677  +      tputs $channel [appendArgs \
         3678  +          "---- HashOps cleanup results: " $result \n]
         3679  +
         3680  +      catch {uplevel 1 [list object invoke -flags +NonPublic \
         3681  +          Eagle._Components.Private.FactoryOps Cleanup]} result
         3682  +
         3683  +      tputs $channel [appendArgs \
         3684  +          "---- FactoryOps cleanup results: " $result \n]
  3458   3685       }
  3459   3686   
  3460   3687       proc evalWithTimeout { script {milliseconds 2000} {resultVarName ""} } {
  3461   3688         #
  3462   3689         # NOTE: Verify that the number of milliseconds requested is greater than
  3463   3690         #       zero.
  3464   3691         #
................................................................................
  3944   4171           getCachedConstraints useCachedConstraints removeConstraint \
  3945   4172           fixConstraints fixTimingConstraints calculateBogoCops \
  3946   4173           calculateRelativePerformance formatTimeStamp formatElapsedTime \
  3947   4174           sourceIfValid processTestArguments getTclShellFileName \
  3948   4175           getTemporaryPath getFiles getTestFiles getTestRunId getTestLogId \
  3949   4176           getDefaultTestLog getTestLog getLastTestLog getTestSuite \
  3950   4177           getTestMachine getTestPlatform getTestConfiguration getTestSuffix \
  3951         -        getTestUncountedLeaks getTestAssemblyName canTestExec testExec \
  3952         -        testClrExec execTestShell isRandomOrder isBreakOnDemand isBreakOnLeak \
  3953         -        isStopOnFailure isStopOnLeak isExitOnComplete returnInfoScript \
  3954         -        runTestPrologue runTestEpilogue hookPuts unhookPuts runTest \
  3955         -        testDebugBreak testArrayGet testShim tsource recordTestStatistics \
  3956         -        reportTestStatistics formatList formatListAsDict pathToRegexp \
         4178  +        getTestUncountedLeaks getRuntimeAssemblyName getTestAssemblyName \
         4179  +        canTestExec testExec testClrExec execTestShell isRandomOrder \
         4180  +        isBreakOnDemand isBreakOnLeak isStopOnFailure isStopOnLeak \
         4181  +        isExitOnComplete returnInfoScript runTestPrologue runTestEpilogue \
         4182  +        hookPuts unhookPuts runTest testDebugBreak testArrayGet testShim \
         4183  +        tsource recordTestStatistics reportTestStatistics formatList \
         4184  +        formatListAsDict pathToRegexp assemblyNameToRegexp \
  3957   4185           inverseLsearchGlob removePathFromFileNames formatDecimal \
  3958   4186           clearTestPercent reportTestPercent runAllTests isTestSuiteRunning \
  3959   4187           getTestChannelOrDefault tryVerifyTestPath checkForAndSetTestPath \
  3960   4188           configureTcltest machineToPlatform getPassPercentage \
  3961   4189           getSkipPercentage] false false
  3962   4190   
  3963   4191       ###########################################################################

Changes to Externals/Eagle/lib/Eagle1.0/unzip.eagle.

    34     34       # NOTE: The base URI used to build the URIs for the unzip command line
    35     35       #       tool downloads.
    36     36       #
    37     37       variable baseUri; # DEFAULT: [getAuxiliaryBaseUri] -OR- https://urn.to/r
    38     38   
    39     39       if {$force || ![info exists baseUri]} then {
    40     40         if {[isEagle]} then {
    41         -        package require Eagle.Update
    42     41           set baseUri [getAuxiliaryBaseUri]
    43     42         } else {
    44     43           set baseUri https://urn.to/r
    45     44         }
    46     45       }
    47     46   
    48     47       #
................................................................................
   144    143     # NOTE: This procedure attempts to use the unzip command line tool in order
   145    144     #       to extract a ZIP archive file.  The archiveFileName argument is the
   146    145     #       ZIP archive file to extract.  The extractRootDirectory argument is
   147    146     #       the location of a directory that should contain a new temporary
   148    147     #       extraction directory.  The actual temporary extraction directory is
   149    148     #       returned.
   150    149     #
   151         -  proc extractZipArchive { archiveFileName extractRootDirectory } {
          150  +  proc extractZipArchive { archiveFileName extractRootDirectory rootOnly } {
   152    151       setupUnzipVars false
   153    152   
   154    153       variable baseUri
   155    154       variable unzipExtractCommand
   156    155       variable unzipUri
   157    156       variable unzipUrn
   158    157       variable unzipVersionCommand
   159    158   
   160    159       set fileName [file nativename $archiveFileName]
   161    160   
   162         -    set extractDirectory [file join $extractRootDirectory \
   163         -        [appendArgs ea-uz-xa- [pid] - [string trim [clock seconds] -]]]
          161  +    if {$rootOnly} then {
          162  +      set extractDirectory $extractRootDirectory
          163  +    } else {
          164  +      set extractDirectory [file join $extractRootDirectory \
          165  +          [appendArgs ea-uz-xa- [pid] - [string trim [clock seconds] -]]]
          166  +    }
   164    167   
   165    168       set directory [file nativename $extractDirectory]
   166    169   
   167    170       if {[isEagle]} then {
   168    171         #
   169    172         # HACK: On Windows only, when the unzip command line tool does
   170    173         #       not appear to be installed, attempt to download it to a

Changes to Externals/Eagle/lib/Eagle1.0/update.eagle.

    21     21   #
    22     22   namespace eval ::Eagle {
    23     23     #
    24     24     # NOTE: This procedure returns non-zero if the specified public key token
    25     25     #       matches the one in use by the Eagle script engine.
    26     26     #
    27     27     proc matchEnginePublicKeyToken { publicKeyToken } {
    28         -    return [expr {[string length $publicKeyToken] == 0 || \
    29         -        $publicKeyToken eq [info engine PublicKeyToken]}]
           28  +    if {[string length $publicKeyToken] == 0} then {
           29  +      return true
           30  +    }
           31  +
           32  +    set enginePublicKeyToken [info engine PublicKeyToken]
           33  +
           34  +    if {[string length $enginePublicKeyToken] == 0} then {
           35  +      return true
           36  +    }
           37  +
           38  +    return [expr {$publicKeyToken eq $enginePublicKeyToken}]
    30     39     }
    31     40   
    32     41     #
    33     42     # NOTE: This procedure returns non-zero if the specified engine name
    34     43     #       matches the Eagle script engine.
    35     44     #
    36     45     proc matchEngineName { name } {
................................................................................
   160    169       if {[llength $args] > 0} then {
   161    170         #
   162    171         # NOTE: Start trusting ONLY our self-signed SSL certificate.
   163    172         #
   164    173         set trusted true
   165    174   
   166    175         if {[lindex [uri softwareupdates] end] eq "untrusted"} then {
   167         -        uri softwareupdates true
          176  +        catch {uri softwareupdates true}
   168    177         } else {
   169    178           set trusted false; # NOTE: Already trusted.
   170    179         }
   171    180   
   172    181         try {
   173    182           #
   174    183           # NOTE: Download the file from the web site.
................................................................................
   176    185           eval uri download $args; # synchronous.
   177    186         } finally {
   178    187           if {$trusted && \
   179    188               [lindex [uri softwareupdates] end] eq "trusted"} then {
   180    189             #
   181    190             # NOTE: Stop trusting ONLY our self-signed SSL certificate.
   182    191             #
   183         -          uri softwareupdates false
          192  +          catch {uri softwareupdates false}
   184    193           }
   185    194         }
   186    195   
   187    196         #
   188    197         # NOTE: Return a result indicating what was done.
   189    198         #
   190    199         return [appendArgs "downloaded URI " [lindex $args 0] \
................................................................................
   197    206     #
   198    207     # NOTE: This procedure runs the updater tool and then immediately exits
   199    208     #       the process.
   200    209     #
   201    210     proc runUpdateAndExit { {automatic false} } {
   202    211       global tcl_platform
   203    212   
   204         -    set directory [file dirname [info nameofexecutable]]
          213  +    #
          214  +    # NOTE: Determine the fully qualified file name for the updater.  If
          215  +    #       it is not available, we cannot continue.
          216  +    #
          217  +    set fileName [file join [file normalize \
          218  +        [file dirname [info nameofexecutable]]] Hippogriff.exe]
   205    219   
   206         -    set command [list exec -shell -- \
   207         -        [file join $directory Hippogriff.exe] -delay 2000]
          220  +    if {![file exists $fileName]} then {
          221  +      error [appendArgs \
          222  +          "updater executable \"" $fileName "\" is not available"]
          223  +    }
          224  +
          225  +    #
          226  +    # NOTE: For .NET Core, updating via the updater tool is unsupported.
          227  +    #
          228  +    if {[isDotNetCore]} then {
          229  +      error [appendArgs \
          230  +          "updater executable \"" $fileName "\" unsupported on .NET Core"]
          231  +    }
          232  +
          233  +    #
          234  +    # NOTE: Start out with just the base [exec] command, -shell option,
          235  +    #       and the end-of-options marker.
          236  +    #
          237  +    set command [list exec -shell --]
          238  +
          239  +    #
          240  +    # NOTE: Check for native Tcl and Mono because this impacts how the
          241  +    #       shell executable name is determined.
          242  +    #
          243  +    if {[isEagle] && [isMono]} then {
          244  +      #
          245  +      # HACK: Assume that Mono is somewhere along the PATH.
          246  +      #
          247  +      lappend command mono \
          248  +          [appendArgs \" [file nativename $fileName] \"]
          249  +    } else {
          250  +      lappend command $fileName
          251  +    }
          252  +
          253  +    #
          254  +    # NOTE: Add the base options to the updater executable.  Typically,
          255  +    #       this only includes the initial (mutex checking) delay.
          256  +    #
          257  +    lappend command -delay 2000
   208    258   
   209    259       #
   210    260       # HACK: The native StrongNameSignatureVerificationEx() function does
   211    261       #       not appear to work on WOA (Windows-on-ARM) on the Surface RT
   212    262       #       tablet; therefore, attempt to disable its use when calling
   213    263       #       into the updater on that platform.
   214    264       #
................................................................................
   309    359     proc getUpdateData { uri } {
   310    360       #
   311    361       # NOTE: Start trusting ONLY our own self-signed SSL certificate.
   312    362       #
   313    363       set trusted true
   314    364   
   315    365       if {[lindex [uri softwareupdates] end] eq "untrusted"} then {
   316         -      uri softwareupdates true
          366  +      catch {uri softwareupdates true}
   317    367       } else {
   318    368         set trusted false; # NOTE: Already trusted.
   319    369       }
   320    370   
   321    371       try {
   322    372         #
   323    373         # NOTE: Download the tag file from the web site.
................................................................................
   325    375         return [uri download -inline $uri]; # synchronous.
   326    376       } finally {
   327    377         if {$trusted && \
   328    378             [lindex [uri softwareupdates] end] eq "trusted"} then {
   329    379           #
   330    380           # NOTE: Stop trusting ONLY our own self-signed SSL certificate.
   331    381           #
   332         -        uri softwareupdates false
          382  +        catch {uri softwareupdates false}
   333    383         }
   334    384       }
   335    385     }
   336    386   
   337    387     #
   338    388     # NOTE: This procedure downloads an update script and then returns it
   339    389     #       verbatim.
................................................................................
   341    391     proc getUpdateScriptData { uri } {
   342    392       #
   343    393       # NOTE: Start trusting ONLY our own self-signed SSL certificate.
   344    394       #
   345    395       set trusted true
   346    396   
   347    397       if {[lindex [uri softwareupdates] end] eq "untrusted"} then {
   348         -      uri softwareupdates true
          398  +      catch {uri softwareupdates true}
   349    399       } else {
   350    400         set trusted false; # NOTE: Already trusted.
   351    401       }
   352    402   
   353    403       try {
   354    404         #
   355    405         # NOTE: Download the script file from the web site.
................................................................................
   357    407         return [interp readorgetscriptfile -- "" $uri]; # synchronous.
   358    408       } finally {
   359    409         if {$trusted && \
   360    410             [lindex [uri softwareupdates] end] eq "trusted"} then {
   361    411           #
   362    412           # NOTE: Stop trusting ONLY our own self-signed SSL certificate.
   363    413           #
   364         -        uri softwareupdates false
          414  +        catch {uri softwareupdates false}
   365    415         }
   366    416       }
   367    417     }
   368    418   
   369    419     #
   370    420     # NOTE: This procedure returns the base URI that should be used to download
   371    421     #       available updates, if a specific base URI is not specified via the

Changes to Externals/Eagle/lib/Eagle1.0/vendor.eagle.

   355    355           $test_overrides : [list binary_directory build_base_directory \
   356    356           build_directory common_directory compile_option_prefix \
   357    357           connection_flags core_library_version database_directory \
   358    358           datetime_format define_constant_prefix execute_on_setup \
   359    359           interop_assembly_file_names native_library_file_names \
   360    360           release_version scratch_directory temporary_directory test_clr \
   361    361           test_clr_v2 test_clr_v4 test_configuration test_configurations \
   362         -        test_constraints test_machine test_net_fx test_net_fx_2005 \
   363         -        test_net_fx_2008 test_net_fx_2010 test_net_fx_2012 test_net_fx_2013 \
   364         -        test_net_fx_2015 test_overrides test_platform test_suite test_year \
   365         -        test_years test_year_clr_v2 test_year_clr_v4 vendor_directory \
   366         -        vendor_test_directory]}] [checkForVendorQuiet checkForTestOverrides]
          362  +        test_constraints test_extra test_extras test_machine \
          363  +        test_native_year test_net_fx test_net_fx_2005 test_net_fx_2008 \
          364  +        test_net_fx_2010 test_net_fx_2012 test_net_fx_2013 \
          365  +        test_net_fx_2015 test_overrides test_platform test_suite \
          366  +        test_year test_years test_year_clr_v2 test_year_clr_v4 \
          367  +        vendor_directory vendor_test_directory]}] \
          368  +        [checkForVendorQuiet checkForTestOverrides]
   367    369   
   368    370       #
   369    371       # NOTE: Set the name of the running test suite, if necessary.
   370    372       #
   371    373       if {![info exists test_suite]} then {
   372    374         set test_suite "System.Data.SQLite Test Suite for Eagle"
   373    375       }

Changes to Externals/Eagle/lib/Test1.0/constraints.eagle.

    18     18   # NOTE: Use our own namespace here because even though we do not directly
    19     19   #       support namespaces ourselves, we do not want to pollute the global
    20     20   #       namespace if this script actually ends up being evaluated in Tcl.
    21     21   #
    22     22   namespace eval ::Eagle {
    23     23     proc getKnownBuildTypes {} {
    24     24       return [list \
    25         -        NetFx20 NetFx35 NetFx40 NetFx45 NetFx451 NetFx452 \
    26         -        NetFx46 NetFx461 NetFx462 NetFx47 NetFx471 Bare \
    27         -        LeanAndMean Database MonoOnUnix Development]
           25  +        NetFx20 NetFx35 NetFx40 NetFx45 NetFx451 \
           26  +        NetFx452 NetFx46 NetFx461 NetFx462 NetFx47 \
           27  +        NetFx471 NetStandard20 Bare LeanAndMean \
           28  +        Database MonoOnUnix Development]
    28     29     }
    29     30   
    30     31     proc getKnownCompileOptions {} {
    31     32       return [list \
    32     33           APPDOMAINS APPROVED_VERBS ARGUMENT_CACHE ARM ARM64 ASSEMBLY_DATETIME \
    33     34           ASSEMBLY_RELEASE ASSEMBLY_STRONG_NAME_TAG ASSEMBLY_TAG ASSEMBLY_TEXT \
    34     35           ASSEMBLY_URI BREAK_ON_EXITING BREAKPOINTS CACHE_ARGUMENT_TOSTRING \
    35     36           CACHE_ARGUMENTLIST_TOSTRING CACHE_DICTIONARY CACHE_RESULT_TOSTRING \
    36     37           CACHE_STATISTICS CACHE_STRINGLIST_TOSTRING CALLBACK_QUEUE CAS_POLICY \
    37     38           CERTIFICATE_PLUGIN CERTIFICATE_POLICY CERTIFICATE_RENEWAL \
    38         -        CODE_ANALYSIS COM_TYPE_CACHE CONSOLE DAEMON DATA DEAD_CODE DEBUG \
    39         -        DEBUGGER DEBUGGER_ARGUMENTS DEBUGGER_ENGINE DEBUGGER_EXECUTE \
    40         -        DEBUGGER_EXPRESSION DEBUGGER_VARIABLE DEBUG_TRACE DEBUG_WRITE \
    41         -        DEMO_EDITION DRAWING DYNAMIC EAGLE EMBEDDED_LIBRARY \
    42         -        EMBED_CERTIFICATES ENTERPRISE_LOCKDOWN EXECUTE_CACHE EXPRESSION_FLAGS \
    43         -        FAST_ERRORCODE FAST_ERRORINFO FOR_TEST_USE_ONLY HAVE_SIZEOF HISTORY \
    44         -        IA64 INTERACTIVE_COMMANDS INTERNALS_VISIBLE_TO ISOLATED_INTERPRETERS \
    45         -        ISOLATED_PLUGINS LIBRARY LICENSING LICENSE_MANAGER LIMITED_EDITION \
    46         -        LIST_CACHE MONO MONO_BUILD MONO_HACKS MONO_LEGACY NATIVE \
    47         -        NATIVE_PACKAGE NATIVE_THREAD_ID NATIVE_UTILITY NATIVE_UTILITY_BSTR \
    48         -        NETWORK NET_20 NET_20_FAST_ENUM NET_20_ONLY NET_20_SP1 NET_20_SP2 \
    49         -        NET_30 NET_35 NET_40 NET_45 NET_451 NET_452 NET_46 NET_461 NET_462 \
    50         -        NET_47 NET_471 NON_WORKING_CODE NOTIFY NOTIFY_ACTIVE NOTIFY_ARGUMENTS \
           39  +        CODE_ANALYSIS COM_TYPE_CACHE CONFIGURATION CONSOLE DAEMON DATA \
           40  +        DEAD_CODE DEBUG DEBUGGER DEBUGGER_ARGUMENTS DEBUGGER_ENGINE \
           41  +        DEBUGGER_EXECUTE DEBUGGER_EXPRESSION DEBUGGER_VARIABLE DEBUG_TRACE \
           42  +        DEBUG_WRITE DEMO_EDITION DRAWING DYNAMIC EAGLE EMBEDDED_LIBRARY \
           43  +        EMBED_CERTIFICATES EMIT ENTERPRISE_LOCKDOWN EXECUTE_CACHE \
           44  +        EXPRESSION_FLAGS FAST_ERRORCODE FAST_ERRORINFO FOR_TEST_USE_ONLY \
           45  +        HAVE_SIZEOF HISTORY IA64 INTERACTIVE_COMMANDS INTERNALS_VISIBLE_TO \
           46  +        ISOLATED_INTERPRETERS ISOLATED_PLUGINS LIBRARY LICENSING \
           47  +        LICENSE_MANAGER LIMITED_EDITION LIST_CACHE MONO MONO_BUILD MONO_HACKS \
           48  +        MONO_LEGACY NATIVE NATIVE_PACKAGE NATIVE_THREAD_ID NATIVE_UTILITY \
           49  +        NATIVE_UTILITY_BSTR NETWORK NET_20 NET_20_FAST_ENUM NET_20_ONLY \
           50  +        NET_20_SP1 NET_20_SP2 NET_30 NET_35 NET_40 NET_45 NET_451 NET_452 \
           51  +        NET_46 NET_461 NET_462 NET_47 NET_471 NET_CORE_20 NET_STANDARD_20 \
           52  +        NON_WORKING_CODE NOTIFY NOTIFY_ACTIVE NOTIFY_ARGUMENTS \
    51     53           NOTIFY_EXCEPTION NOTIFY_EXECUTE NOTIFY_EXPRESSION NOTIFY_GLOBAL \
    52     54           NOTIFY_OBJECT OBSOLETE OBFUSCATION OFFICIAL PARSE_CACHE PATCHLEVEL \
    53     55           PLUGIN_COMMANDS POLICY_TRACE PREVIOUS_RESULT RANDOMIZE_ID REMOTING \
    54     56           RESULT_LIMITS SAMPLE SECURITY SERIALIZATION SHARED_ID_POOL SHELL \
    55     57           SOURCE_ID SOURCE_TIMESTAMP STATIC TCL TCL_KITS TCL_THREADED \
    56     58           TCL_THREADS TCL_UNICODE TCL_WRAPPER TEST TEST_PLUGIN THREADING \
    57     59           THROW_ON_DISPOSED TRACE TYPE_CACHE UNIX USE_APPDOMAIN_FOR_ID \
................................................................................
    76     78       #
    77     79       if {$force || ![info exists ::no(monoVersions)]} then {
    78     80         return [list \
    79     81             [list 2 0] [list 2 2] [list 2 4] [list 2 6] [list 2 8] [list 2 10] \
    80     82             [list 2 11] [list 3 0] [list 3 1] [list 3 2] [list 3 4] [list 3 6] \
    81     83             [list 3 8] [list 3 10] [list 3 12] [list 4 0] [list 4 2] [list 4 4] \
    82     84             [list 4 6] [list 4 8] [list 5 0] [list 5 2] [list 5 4] [list 5 8] \
    83         -          [list 5 10]]
           85  +          [list 5 10] [list 5 12]]
    84     86       } else {
    85     87         return [list]
    86     88       }
    87     89     }
    88     90   
    89     91     proc addKnownMonoConstraints { generic } {
    90     92       #
................................................................................
   161    163         }
   162    164   
   163    165         lappend result $version
   164    166       }
   165    167   
   166    168       return $result
   167    169     }
          170  +
          171  +  proc getDotNetCoreDirectoryNameOnly { path } {
          172  +    #
          173  +    # HACK: Obtain parent directory name that matches "net*", if any (e.g.
          174  +    #       "netcoreapp2.0", "netstandard2.0", etc).
          175  +    #
          176  +    if {[string length $path] > 0} then {
          177  +      set tail [file tail $path]
          178  +
          179  +      if {[string match net* $tail]} then {
          180  +        return $tail
          181  +      }
          182  +    }
          183  +
          184  +    return ""
          185  +  }
          186  +
          187  +  proc getDotNetCoreLibPathDirectoryNameOnly { {name ""} } {
          188  +    #
          189  +    # NOTE: Search for matching directories based on the globally detected
          190  +    #       library path associated with the current core library.
          191  +    #
          192  +    if {[info exists ::core_lib_path] && \
          193  +        [string length $::core_lib_path] > 0} then {
          194  +      #
          195  +      # NOTE: Make sure the directory actually exists before trying to find
          196  +      #       things within it.
          197  +      #
          198  +      if {[file isdirectory $::core_lib_path]} then {
          199  +        #
          200  +        # NOTE: Grab all directories that are directly beneath the detected
          201  +        #       library path, if any.
          202  +        #
          203  +        foreach directory [glob \
          204  +            -nocomplain -types {d} -- [file join $::core_lib_path *]] {
          205  +          #
          206  +          # NOTE: If the caller specified a (plugin) name to match against,
          207  +          #       make sure it matches; otherwise, skip this directory.
          208  +          #
          209  +          if {[string length $name] > 0 && \
          210  +              ![string match $name [file tail $directory]]} then {
          211  +            continue
          212  +          }
          213  +
          214  +          #
          215  +          # NOTE: Find directories beneath the current candidate directory
          216  +          #       that are .NET Core output directories.
          217  +          #
          218  +          set directories [glob \
          219  +              -nocomplain -types {d} -- [file join $directory net*]]
          220  +
          221  +          #
          222  +          # NOTE: If there is at least one match, we are done.  Return the
          223  +          #       final path segment of the directory name to the caller.
          224  +          #
          225  +          if {[llength $directories] > 0} then {
          226  +            return [file tail [lindex $directories 0]]
          227  +          }
          228  +        }
          229  +      }
          230  +    }
          231  +
          232  +    #
          233  +    # NOTE: There was no match, just return something obviously invalid.
          234  +    #
          235  +    return ""
          236  +  }
   168    237   
   169    238     proc getDottedVersion { version } {
   170    239       return [join $version .]
   171    240     }
   172    241   
   173    242     proc getDotlessVersion { version } {
   174    243       if {[string first . $version] != -1} then {
................................................................................
   343    412     #
   344    413     # NOTE: This procedure should return non-zero if the test suite should be
   345    414     #       considered to be running on Mono.
   346    415     #
   347    416     proc isTestMono {} {
   348    417       return [expr {![info exists ::no(mono)] && [isMono]}]
   349    418     }
          419  +
          420  +  #
          421  +  # NOTE: This procedure should return non-zero if the test suite should be
          422  +  #       considered to be running on .NET Core.
          423  +  #
          424  +  proc isTestDotNetCore {} {
          425  +    return [expr {![info exists ::no(dotNetCore)] && [isDotNetCore]}]
          426  +  }
   350    427   
   351    428     proc isTestAdministrator { {force false} } {
   352    429       #
   353    430       # NOTE: This is a workaround for the [isAdministrator] procedure being
   354    431       #       inaccurate for Mono on Windows, primarily due to the inability
   355    432       #       of Mono to call a P/Invoke method by ordinal.  Also, this can
   356    433       #       be used for native Tcl on Windows.  This only works on Windows.
................................................................................
  1378   1455         #
  1379   1456         if {$match} then {
  1380   1457           #
  1381   1458           # NOTE: We are running in Eagle via the EagleShell.
  1382   1459           #
  1383   1460           addConstraint shell
  1384   1461           addConstraint [appendArgs shell. $name]
         1462  +        addConstraint dotNetCoreOrShell
  1385   1463   
  1386   1464           tputs $channel "yes (Eagle)\n"
  1387   1465   
  1388   1466           #
  1389   1467           # NOTE: We are done here, return now.
  1390   1468           #
  1391   1469           return
................................................................................
  1393   1471       } else {
  1394   1472         if {[string match tclsh* $name]} then {
  1395   1473           #
  1396   1474           # NOTE: We are running in Tcl via tclsh.
  1397   1475           #
  1398   1476           addConstraint shell
  1399   1477           addConstraint [appendArgs shell. $name]
         1478  +        addConstraint dotNetCoreOrShell
  1400   1479   
  1401   1480           tputs $channel "yes (Tcl)\n"
  1402   1481   
  1403   1482           #
  1404   1483           # NOTE: We are done here, return now.
  1405   1484           #
  1406   1485           return
................................................................................
  2741   2820       }
  2742   2821   
  2743   2822       proc checkForStrongName { channel } {
  2744   2823         tputs $channel "---- checking for strong name... "
  2745   2824   
  2746   2825         if {[catch {
  2747   2826           object invoke Interpreter.GetActive GetStrongName
  2748         -      } strongName] == 0 && [string length $strongName] > 0} then {
         2827  +      } strongName] == 0 && [isNonNullObjectHandle $strongName]} then {
  2749   2828           #
  2750   2829           # NOTE: Yes, it appears that the core library was signed with a
  2751   2830           #       strong name key.
  2752   2831           #
  2753   2832           addConstraint strongName
  2754   2833   
  2755   2834           tputs $channel yes\n
................................................................................
  2837   2916       }
  2838   2917   
  2839   2918       proc checkForCertificate { channel } {
  2840   2919         tputs $channel "---- checking for certificate... "
  2841   2920   
  2842   2921         if {[catch {
  2843   2922           object invoke Interpreter.GetActive GetCertificate
  2844         -      } certificate] == 0 && [string length $certificate] > 0} then {
         2923  +      } certificate] == 0 && [isNonNullObjectHandle $certificate]} then {
  2845   2924           #
  2846   2925           # NOTE: Yes, it appears that the core library was signed with a
  2847   2926           #       code-signing certificate.
  2848   2927           #
  2849   2928           addConstraint certificate
  2850   2929   
  2851   2930           #
................................................................................
  2865   2944           tputs $channel no\n
  2866   2945         }
  2867   2946       }
  2868   2947   
  2869   2948       proc checkForCompileCSharp { channel } {
  2870   2949         tputs $channel "---- checking for test use of C# compiler... "
  2871   2950   
  2872         -      if {![info exists ::no(compileCSharp)]} then {
         2951  +      if {![info exists ::no(compileCSharp)] && \
         2952  +          [doesCompileCSharpWork]} then {
  2873   2953           addConstraint compileCSharp
  2874   2954   
  2875   2955           tputs $channel yes\n
  2876   2956         } else {
  2877   2957           tputs $channel no\n
  2878   2958         }
  2879   2959       }
................................................................................
  2948   3028       }
  2949   3029   
  2950   3030       proc checkForDefaultAppDomain { channel } {
  2951   3031         tputs $channel "---- checking for default application domain... "
  2952   3032   
  2953   3033         if {[catch {
  2954   3034           object invoke AppDomain CurrentDomain
  2955         -      } appDomain] == 0 && [string length $appDomain] > 0} then {
         3035  +      } appDomain] == 0 && [isNonNullObjectHandle $appDomain]} then {
  2956   3036           if {[catch {
  2957   3037             object invoke $appDomain IsDefaultAppDomain
  2958   3038           } default] || [string length $default] == 0} then {
  2959   3039             set default false
  2960   3040           }
  2961   3041   
  2962   3042           if {[catch {object invoke $appDomain Id} id] || \
................................................................................
  2976   3056         }
  2977   3057       }
  2978   3058   
  2979   3059       proc checkForRuntime { channel } {
  2980   3060         tputs $channel "---- checking for runtime... "
  2981   3061   
  2982   3062         #
  2983         -      # NOTE: Are we running inside Mono (regardless of operating system)?
         3063  +      # NOTE: Are we running inside Mono -OR- on .NET Core (regardless
         3064  +      #       of operating system)?
  2984   3065         #
  2985         -      if {[isTestMono]} then {
         3066  +      if {[isTestDotNetCore]} then {
         3067  +        #
         3068  +        # NOTE: Yes, it appears that we are running on .NET Core.
         3069  +        #
         3070  +        addConstraint dotNetCore; # running on .NET Core.
         3071  +        addConstraint dotNetOrDotNetCore
         3072  +        addConstraint dotNetCoreOrShell
         3073  +
         3074  +        #
         3075  +        # NOTE: We do not want to skip Mono bugs on .NET Core.
         3076  +        #
         3077  +        addKnownMonoConstraints true; # running on .NET Core.
         3078  +
         3079  +        tputs $channel [appendArgs [expr {[info exists \
         3080  +            ::eagle_platform(runtime)] ? \
         3081  +            $::eagle_platform(runtime) : ".NET Core"}] \n]
         3082  +      } elseif {[isTestMono]} then {
  2986   3083           #
  2987   3084           # NOTE: Yes, it appears that we are running inside Mono.
  2988   3085           #
  2989   3086           addConstraint mono; # running on Mono.
         3087  +        addConstraint monoOrDotNetCore
  2990   3088   
  2991   3089           tputs $channel [appendArgs [expr {[info exists \
  2992   3090               ::eagle_platform(runtime)] ? \
  2993   3091               $::eagle_platform(runtime) : "Mono"}] \n]
  2994   3092         } else {
  2995   3093           #
  2996         -        # NOTE: No, it appears that we are not running inside Mono.
         3094  +        # NOTE: It appears that we are running on the full .NET.
  2997   3095           #
  2998   3096           addConstraint dotNet; # running on .NET.
         3097  +        addConstraint dotNetOrDotNetCore
  2999   3098   
  3000   3099           #
  3001   3100           # NOTE: We do not want to skip Mono bugs on .NET.
  3002   3101           #
  3003   3102           addKnownMonoConstraints true; # running on .NET.
  3004   3103   
  3005   3104           tputs $channel [appendArgs [expr {[info exists \
................................................................................
  3110   3209             if {$dotVersion(1) eq $dotVersion(2)} then {
  3111   3210               #
  3112   3211               # NOTE: Yes, the image runtime version matches the framework.
  3113   3212               #
  3114   3213               addConstraint matchFramework
  3115   3214               addConstraint [appendArgs matchFramework $version(1)]
  3116   3215   
  3117         -            addConstraint dotnetMatchFramework
  3118         -            addConstraint [appendArgs dotnetMatchFramework $version(1)]
         3216  +            addConstraint dotNetMatchFramework
         3217  +            addConstraint [appendArgs dotNetMatchFramework $version(1)]
  3119   3218   
  3120   3219               addConstraint monoMatchFramework
  3121   3220               addConstraint [appendArgs monoMatchFramework $version(1)]
  3122   3221   
         3222  +            addConstraint dotNetCoreMatchFramework
         3223  +            addConstraint [appendArgs dotNetCoreMatchFramework $version(1)]
         3224  +
  3123   3225               tputs $channel yes\n
  3124   3226             } else {
  3125         -            if {[isMono]} then {
  3126         -              addConstraint dotnetMatchFramework
  3127         -              addConstraint [appendArgs dotnetMatchFramework $version(1)]
         3227  +            if {[isTestDotNetCore]} then {
         3228  +              addConstraint dotNetMatchFramework
         3229  +              addConstraint [appendArgs dotNetMatchFramework $version(1)]
         3230  +
         3231  +              addConstraint monoMatchFramework
         3232  +              addConstraint [appendArgs monoMatchFramework $version(1)]
         3233  +            } elseif {[isTestMono]} then {
         3234  +              addConstraint dotNetMatchFramework
         3235  +              addConstraint [appendArgs dotNetMatchFramework $version(1)]
         3236  +
         3237  +              addConstraint dotNetCoreMatchFramework
         3238  +              addConstraint [appendArgs dotNetCoreMatchFramework $version(1)]
  3128   3239               } else {
  3129   3240                 addConstraint monoMatchFramework
  3130   3241                 addConstraint [appendArgs monoMatchFramework $version(1)]
         3242  +
         3243  +              addConstraint dotNetCoreMatchFramework
         3244  +              addConstraint [appendArgs dotNetCoreMatchFramework $version(1)]
  3131   3245               }
  3132   3246   
  3133   3247               tputs $channel no\n
  3134   3248             }
  3135   3249           } else {
  3136   3250             tputs $channel "no, missing image runtime version\n"
  3137   3251           }
................................................................................
  3153   3267   
  3154   3268           #
  3155   3269           # NOTE: Now create a version string for use in the constraint name
  3156   3270           #       (remove the periods).
  3157   3271           #
  3158   3272           set version [string map [list . ""] $dotVersion]
  3159   3273   
  3160         -        if {[isTestMono]} then {
         3274  +        if {[isTestDotNetCore]} then {
         3275  +          #
         3276  +          # NOTE: If the runtime version was found, add a test constraint
         3277  +          #       for it now.
         3278  +          #
         3279  +          if {[string length $version] > 0} then {
         3280  +            #
         3281  +            # NOTE: We are running on the .NET Core.  Keep track of the
         3282  +            #       specific version for usage in test constraints.
         3283  +            #
         3284  +            addConstraint [appendArgs dotNetCore $version]
         3285  +            addConstraint [appendArgs dotNetCore $version OrHigher]
         3286  +          }
         3287  +
         3288  +          #
         3289  +          # NOTE: We do not want to skip any Mono bugs on .NET Core.  Add
         3290  +          #       the necessary constraints for each version of Mono we
         3291  +          #       know about.
         3292  +          #
         3293  +          addKnownMonoConstraints false; # running on .NET.
         3294  +        } elseif {[isTestMono]} then {
  3161   3295             #
  3162   3296             # NOTE: If the runtime version was found, add a test constraint
  3163   3297             #       for it now.
  3164   3298             #
  3165   3299             if {[string length $version] > 0} then {
  3166   3300                 #
  3167   3301                 # NOTE: We are running on Mono.  Keep track of the specific
................................................................................
  3504   3638           addConstraint [appendArgs runtime. $option]
  3505   3639   
  3506   3640           tputs $channel yes\n
  3507   3641         } else {
  3508   3642           tputs $channel no\n
  3509   3643         }
  3510   3644       }
         3645  +
         3646  +    proc testForDynamicLoading { {fileName ""} } {
         3647  +      if {[catch {
         3648  +        if {[isWindows] && [string length $fileName] == 0} then {
         3649  +          set fileName kernel32; # HACK: Always pre-loaded?
         3650  +        }
         3651  +
         3652  +        set error null
         3653  +
         3654  +        object invoke -flags +NonPublic \
         3655  +            Eagle._Components.Private.NativeOps TestLoadLibrary \
         3656  +            $fileName error
         3657  +      } code] == 0 && $code eq "Ok"} then {
         3658  +        return true
         3659  +      }
         3660  +
         3661  +      return false
         3662  +    }
  3511   3663   
  3512   3664       proc checkForDynamicLoading { channel } {
  3513   3665         tputs $channel "---- checking for dynamic loading... "
  3514   3666   
  3515   3667         #
  3516   3668         # NOTE: As far as we know, dynamic loading always works on Windows.
  3517   3669         #       On some Unix systems, dlopen does not work (e.g. because
  3518   3670         #       Mono is statically linked, etc).
  3519   3671         #
  3520         -      if {[isWindows] || ([llength [info commands library]] > 0 && \
  3521         -          [catch {library test}] == 0)} then {
         3672  +      if {[isWindows] || [testForDynamicLoading]} then {
  3522   3673           #
  3523   3674           # NOTE: Yes, it appears that it is available.
  3524   3675           #
  3525   3676           addConstraint dynamic
  3526   3677   
  3527   3678           tputs $channel yes\n
  3528   3679         } else {
................................................................................
  3713   3864           }
  3714   3865   
  3715   3866           tputs $channel yes\n
  3716   3867         } else {
  3717   3868           tputs $channel no\n
  3718   3869         }
  3719   3870       }
         3871  +
         3872  +    proc checkForExcelUsable { channel } {
         3873  +      tputs $channel "---- checking for usable instance of Excel... "
         3874  +
         3875  +      #
         3876  +      # NOTE: As of this writing, this check is only supported on Windows.
         3877  +      #
         3878  +      if {[isWindows]} then {
         3879  +        #
         3880  +        # NOTE: This constraint check must run after the interop assembly for
         3881  +        #       Excel has been detected, because this check makes use of it.
         3882  +        #
         3883  +        if {[haveConstraint Microsoft.Office.Interop.Excel]} then {
         3884  +          #
         3885  +          # NOTE: This constraint check requires the (optional) interpreter
         3886  +          #       isolation feature of Eagle in order to keep the primary
         3887  +          #       interpreter and AppDomain tidy.  It also requires access
         3888  +          #       to native Windows support in order to use the [info hwnd]
         3889  +          #       sub-command.
         3890  +          #
         3891  +          if {[haveConstraint compile.ISOLATED_INTERPRETERS] && \
         3892  +              [haveConstraint compile.NATIVE] && \
         3893  +              [haveConstraint compile.WINDOWS]} then {
         3894  +            try {
         3895  +              if {[catch {
         3896  +                #
         3897  +                # NOTE: In an attempt to limit the assemblies loaded into the
         3898  +                #       primary AppDomain, create an isolated interpreter.
         3899  +                #
         3900  +                set interp [interp create -isolated]
         3901  +
         3902  +                #
         3903  +                # NOTE: Give the newly created (isolated) interpreter a means
         3904  +                #       to set variables in the parent (this) interpreter.
         3905  +                #
         3906  +                interp alias $interp pset {} set; # parent set
         3907  +
         3908  +                #
         3909  +                # NOTE: Evaluate all the Excel interop assembly related code
         3910  +                #       in the other AppDomain.
         3911  +                #
         3912  +                interp eval $interp {
         3913  +                  #
         3914  +                  # NOTE: First, attempt to load the Excel interop assembly.
         3915  +                  #       If this fails, we cannot continue and Excel is not
         3916  +                  #       considered usable.
         3917  +                  #
         3918  +                  set assembly [object load -import -declare \
         3919  +                      Microsoft.Office.Interop.Excel]
         3920  +
         3921  +                  #
         3922  +                  # NOTE: Next, attempt to run the Excel application using
         3923  +                  #       its automation object model.  If this fails, we
         3924  +                  #       cannot continue and Excel is not considered usable.
         3925  +                  #
         3926  +                  set application [object create -alias \
         3927  +                      Microsoft.Office.Interop.Excel.ApplicationClass]; # run
         3928  +
         3929  +                  #
         3930  +                  # NOTE: Next, attempt to extract the process ID associated
         3931  +                  #       with the Excel application window.  This is used to
         3932  +                  #       help make sure the running Excel instance is closed
         3933  +                  #       after our testing is complete.  Generally, this will
         3934  +                  #       not fail because we know the [info hwnd] sub-command
         3935  +                  #       should be available, due to define constant checks.
         3936  +                  #
         3937  +                  pset pid [getDictionaryValue \
         3938  +                      [info hwnd [$application Hwnd]] processId]
         3939  +
         3940  +                  #
         3941  +                  # NOTE: Next, attempt to make sure that the Excel instance
         3942  +                  #       is not visible and will not display alerts/prompts.
         3943  +                  #       If this fails, Excel is not considered usable.
         3944  +                  #
         3945  +                  $application Visible false
         3946  +                  $application DisplayAlerts false
         3947  +
         3948  +                  #
         3949  +                  # NOTE: Next, create a value of an enumerated type exposed
         3950  +                  #       by the Excel automation object model so that we can
         3951  +                  #       add a new workbook.  Generally, this does not fail.
         3952  +                  #       If this fails, Excel is not considered usable.
         3953  +                  #
         3954  +                  set enumValue [object invoke -create \
         3955  +                      Enum Parse XlWBATemplate xlWBATWorksheet]
         3956  +
         3957  +                  #
         3958  +                  # NOTE: Next, attempt to add a new workbook.  If this fails,
         3959  +                  #       Excel is not considered usable.
         3960  +                  #
         3961  +                  set workbook [object invoke -alias \
         3962  +                      $application.Workbooks Add $enumValue]
         3963  +
         3964  +                  #
         3965  +                  # NOTE: The test package is needed in order to make use of
         3966  +                  #       the [getTemporaryFileName] procedure.
         3967  +                  #
         3968  +                  package require Eagle.Test
         3969  +
         3970  +                  #
         3971  +                  # NOTE: Setup a temporary file name that can be used to save
         3972  +                  #       the Excel spreadsheet.
         3973  +                  #
         3974  +                  pset fileName [set fileName [file nativename \
         3975  +                      [appendArgs [getTemporaryFileName] .xls]]]
         3976  +
         3977  +                  #
         3978  +                  # NOTE: Next, attempt to save a new workbook.  If this fails,
         3979  +                  #       Excel is not considered usable.
         3980  +                  #
         3981  +                  $workbook SaveAs $fileName
         3982  +
         3983  +                  #
         3984  +                  # NOTE: Next, attempt to close Excel.  If this fails, Excel
         3985  +                  #       is not considered usable.
         3986  +                  #
         3987  +                  $application Quit; # close
         3988  +
         3989  +                  #
         3990  +                  # NOTE: Finally, cleanup our local state just to be tidy.
         3991  +                  #
         3992  +                  unset workbook enumValue application assembly; # dispose
         3993  +                }
         3994  +              } result] == 0} then {
         3995  +                #
         3996  +                # NOTE: It appears the Excel instance is usable.
         3997  +                #
         3998  +                addConstraint excel.usable
         3999  +
         4000  +                #
         4001  +                # NOTE: Show that a usable Excel instance was found.
         4002  +                #
         4003  +                tputs $channel yes\n
         4004  +              } else {
         4005  +                #
         4006  +                # NOTE: This is the list of error message patterns that may
         4007  +                #       indicate a trial version of Excel is being used.
         4008  +                #
         4009  +                set patterns [list \
         4010  +                    "* 0x800AC472*" "* 0x800A03EC*" \
         4011  +                    "* application has expired.*"]
         4012  +
         4013  +                #
         4014  +                # NOTE: Check each error message pattern.  Upon finding any
         4015  +                #       match, mark Excel as unusable due to being a trial
         4016  +                #       edition and then stop.
         4017  +                #
         4018  +                foreach pattern $patterns {
         4019  +                  #
         4020  +                  # TODO: For now, just use [string match] here; eventually,
         4021  +                  #       regular expressions may be needed.
         4022  +                  #
         4023  +                  if {[string match $pattern $result]} then {
         4024  +                    #
         4025  +                    # NOTE: It appears that Excel is a trial edition.
         4026  +                    #
         4027  +                    addConstraint excel.trial
         4028  +
         4029  +                    #
         4030  +                    # NOTE: Show that the Excel trial edition was found.
         4031  +                    #
         4032  +                    tputs $channel "no, trial\n"
         4033  +
         4034  +                    #
         4035  +                    # NOTE: We are done here, return now.
         4036  +                    #
         4037  +                    return
         4038  +                  }
         4039  +                }
         4040  +
         4041  +                #
         4042  +                # NOTE: It appears the Excel instance is not usable.
         4043  +                #
         4044  +                addConstraint excel.unusable
         4045  +
         4046  +                #
         4047  +                # NOTE: Show that a unusable Excel instance was found.
         4048  +                #
         4049  +                tputs $channel "no, broken\n"
         4050  +              }
         4051  +            } finally {
         4052  +              #
         4053  +              # NOTE: Make sure the isolated interpreter is deleted if it was
         4054  +              #       actually created.
         4055  +              #
         4056  +              if {[info exists interp] && [interp exists $interp]} then {
         4057  +                catch {interp delete $interp}
         4058  +              }
         4059  +
         4060  +              #
         4061  +              # NOTE: Make sure the Excel process is (forcibly) closed if it
         4062  +              #       is still running at this point.
         4063  +              #
         4064  +              if {[info exists pid] && $pid in [getProcesses excel]} then {
         4065  +                catch {kill -force $pid}
         4066  +              }
         4067  +
         4068  +              #
         4069  +              # NOTE: Make sure the temporary spreadsheet file is deleted if
         4070  +              #       it was actually created.
         4071  +              #
         4072  +              if {[info exists fileName] && [file exists $fileName]} then {
         4073  +                catch {file delete $fileName}
         4074  +              }
         4075  +            }
         4076  +          } else {
         4077  +            tputs $channel "unknown, missing optional feature\n"
         4078  +          }
         4079  +        } else {
         4080  +          tputs $channel "unknown, no Excel interop assembly\n"
         4081  +        }
         4082  +      } else {
         4083  +        tputs $channel "unknown, not running on Windows\n"
         4084  +      }
         4085  +    }
  3720   4086   
  3721   4087       proc checkForTclInstalls { channel } {
  3722   4088         tputs $channel "---- checking for Tcl installs... "
  3723   4089   
  3724   4090         #
  3725   4091         # NOTE: Check for dynamically loadable Tcl libraries (for this
  3726   4092         #       architecture only).
................................................................................
  4637   5003         #
  4638   5004         if {[catch {
  4639   5005           object invoke -flags +NonPublic Interpreter.GetActive Debugger
  4640   5006         } debugger] == 0} then {
  4641   5007           #
  4642   5008           # NOTE: We do not own this, do not dispose it.
  4643   5009           #
  4644         -        if {[string length $debugger] > 0} then {
         5010  +        if {[isNonNullObjectHandle $debugger]} then {
  4645   5011             catch {object flags $debugger +NoDispose}
  4646   5012           }
  4647   5013   
  4648   5014           if {[regexp -- {^Debugger#\d+$} $debugger]} then {
  4649   5015             #
  4650   5016             # NOTE: Yes, it appears that it is available.
  4651   5017             #
................................................................................
  4671   5037         #
  4672   5038         if {[catch {
  4673   5039           object invoke -flags +NonPublic Interpreter.GetActive Debugger
  4674   5040         } debugger] == 0} then {
  4675   5041           #
  4676   5042           # NOTE: We do not own this, do not dispose it.
  4677   5043           #
  4678         -        if {[string length $debugger] > 0} then {
         5044  +        if {[isNonNullObjectHandle $debugger]} then {
  4679   5045             catch {object flags $debugger +NoDispose}
  4680   5046           }
  4681   5047   
  4682   5048           if {[regexp -- {^Debugger#\d+$} $debugger] && \
  4683   5049               [catch {object invoke $debugger Interpreter} interp] == 0} then {
  4684   5050             #
  4685   5051             # NOTE: We do not own this, do not dispose it.
  4686   5052             #
  4687         -          if {[string length $interp] > 0} then {
         5053  +          if {[isNonNullObjectHandle $interp]} then {
  4688   5054               catch {object flags $interp +NoDispose}
  4689   5055             }
  4690   5056   
  4691   5057             if {[regexp -- {^Interpreter#\d+$} $interp]} then {
  4692   5058               #
  4693   5059               # NOTE: Yes, it appears that it is available.
  4694   5060               #
................................................................................
  4717   5083   
  4718   5084       #
  4719   5085       # NOTE: We need several of our test constraint related commands in the
  4720   5086       #       global namespace.
  4721   5087       #
  4722   5088       exportAndImportPackageCommands [namespace current] [list \
  4723   5089           getKnownBuildTypes getKnownCompileOptions getKnownMonoVersions \
  4724         -        addKnownMonoConstraints lpermute alwaysFullInterpReady canExecComSpec \
  4725         -        canExecWhoAmI canExecTclShell canExecFossil canExecVsWhere isTestMono \
  4726         -        isTestAdministrator canPing cleanConstraintName cleanPackageName \
  4727         -        haveTclPlatformOsExtraUpdateName checkForTestSuiteFiles \
  4728         -        checkForPlatform checkForWindowsVersion checkForOperatingSystemUpdate \
  4729         -        checkForScriptLibrary checkForVariable checkForTclOptions \
  4730         -        checkForWindowsCommandProcessor checkForPackage checkForFossil \
  4731         -        checkForVisualStudioViaVsWhere checkForEagle checkForSymbols \
  4732         -        checkForLogFile checkForGaruda checkForShell \
         5090  +        addKnownMonoConstraints getDotNetCoreLibPathDirectoryNameOnly \
         5091  +        lpermute alwaysFullInterpReady canExecComSpec canExecWhoAmI \
         5092  +        canExecTclShell canExecFossil canExecVsWhere isTestMono \
         5093  +        isTestDotNetCore isTestAdministrator canPing cleanConstraintName \
         5094  +        cleanPackageName haveTclPlatformOsExtraUpdateName \
         5095  +        checkForTestSuiteFiles checkForPlatform checkForWindowsVersion \
         5096  +        checkForOperatingSystemUpdate checkForScriptLibrary checkForVariable \
         5097  +        checkForTclOptions checkForWindowsCommandProcessor checkForPackage \
         5098  +        checkForFossil checkForVisualStudioViaVsWhere checkForEagle \
         5099  +        checkForSymbols checkForLogFile checkForGaruda checkForShell \
  4733   5100           checkForOfficialStableReleaseInProgress checkForDebug checkForTk \
  4734   5101           checkForVersion checkForCommand checkForSubCommand checkForNamespaces \
  4735   5102           checkForTestExec checkForTestMachine checkForTestPlatform \
  4736   5103           checkForTestConfiguration checkForTestSuffix checkForFile \
  4737   5104           checkForPathFile checkForNativeCode checkForTip127 checkForTip194 \
  4738   5105           checkForTip207 checkForTip241 checkForTip285 checkForTip405 \
  4739   5106           checkForTip421 checkForTip426 checkForTip429 checkForTip440 \

Changes to Externals/Eagle/lib/Test1.0/prologue.eagle.

   170    170     if {![info exists bin_path]} then {
   171    171       set bin_path [file normalize [file dirname $bin_file]]
   172    172     }
   173    173   
   174    174     #
   175    175     # NOTE: Set the location of the [non-script] library directory
   176    176     #       (i.e. the directory where the plugins are located), if
   177         -  #       necessary.
          177  +  #       necessary.  This variant is based on where the process
          178  +  #       executable is located.
   178    179     #
   179    180     if {![info exists lib_path]} then {
   180    181       #
   181    182       # NOTE: This should go one directory up from the directory
   182    183       #       containing the executable file for the process (e.g.
   183    184       #       the shell) and then into the "lib" directory just
   184    185       #       beneath that.
   185    186       #
   186    187       set lib_path [file normalize [file join [file dirname $bin_path] lib]]
   187    188     }
          189  +
          190  +  #
          191  +  # NOTE: Set the location of the Eagle core library -OR- Tcl core
          192  +  #       library file is located.  This may be different than the
          193  +  #       location of the (shell?) executable file.
          194  +  #
          195  +  if {![info exists core_bin_path]} then {
          196  +    #
          197  +    # NOTE: Attempt to obtain the information for the Eagle core
          198  +    #       library assembly.  This will not work for native Tcl.
          199  +    #
          200  +    if {[catch {info assembly} bin_dir] == 0} then {
          201  +      #
          202  +      # NOTE: Grab the directory for the core library assembly.
          203  +      #
          204  +      set core_bin_path [file dirname [lindex $bin_dir end]]
          205  +    } else {
          206  +      #
          207  +      # NOTE: This is native Tcl.  There is no way to query the
          208  +      #       path for the Tcl core library itself (e.g. "tcl*.dll",
          209  +      #       "libtcl*.so", etc); however, using [info library] is
          210  +      #       close enough.
          211  +      #
          212  +      set core_bin_path [file dirname [info library]]
          213  +    }
          214  +
          215  +    unset bin_dir
          216  +  }
          217  +
          218  +  #
          219  +  # NOTE: Set the location of the [non-script] library directory
          220  +  #       (i.e. the directory where the plugins are located), if
          221  +  #       necessary.  This variant is based on where the Eagle
          222  +  #       core library -OR- Tcl core library file is located.
          223  +  #
          224  +  if {![info exists core_lib_path]} then {
          225  +    #
          226  +    # NOTE: Start with the directory for the core library assembly.
          227  +    #
          228  +    set core_lib_path $core_bin_path
          229  +
          230  +    #
          231  +    # NOTE: Perform a check for the .NET Core output directories
          232  +    #       (e.g. "netcoreapp2.0", etc), which must be removed
          233  +    #       if present, prior to further checks.
          234  +    #
          235  +    if {![info exists no(dotNetCoreLibPath)] && \
          236  +        [string match net* [file tail $core_lib_path]]} then {
          237  +      #
          238  +      # NOTE: Remove the .NET Core output directory name.
          239  +      #
          240  +      set core_lib_path [file dirname $core_lib_path]
          241  +    }
          242  +
          243  +    #
          244  +    # NOTE: Go up one level, to remove the "bin" directory and
          245  +    #       then append the "lib" directory.  This gives us the
          246  +    #       final path we need.
          247  +    #
          248  +    set core_lib_path [file normalize \
          249  +        [file join [file dirname $core_lib_path] lib]]
          250  +  }
   188    251   
   189    252     #
   190    253     # NOTE: Set the web host to test against, if necessary.
   191    254     #
   192    255     if {![info exists test_host]} then {
   193    256       set test_host eagle.to
   194    257     }
................................................................................
   621    684                   ![haveConstraint quiet]} then {
   622    685                 tputs $test_channel \
   623    686                     "==== WARNING: attempting automatic Tcl shell selection...\n"
   624    687               }
   625    688   
   626    689               set test_tclsh [getTclShellFileName \
   627    690                   [expr {![info exists no(automaticTclShell)]}] \
   628         -                [expr {![info exists no(tclKit)]}]]
          691  +                [expr {![info exists no(tclKit)]}] \
          692  +                [expr {[info exists test_machine] ? $test_machine : ""}]]
   629    693             } else {
   630    694               #
   631    695               # NOTE: Skip detection and use the fallback default.
   632    696               #
   633    697               set test_tclsh tclsh
   634    698             }
   635    699           }
................................................................................
   945   1009         $root_path \"\n]
   946   1010   
   947   1011     tputs $test_channel [appendArgs "---- binary path: \"" \
   948   1012         $bin_path \"\n]
   949   1013   
   950   1014     tputs $test_channel [appendArgs "---- library path: \"" \
   951   1015         $lib_path \"\n]
         1016  +
         1017  +  tputs $test_channel [appendArgs "---- core binary path: \"" \
         1018  +      $core_bin_path \"\n]
         1019  +
         1020  +  tputs $test_channel [appendArgs "---- core library path: \"" \
         1021  +      $core_lib_path \"\n]
   952   1022   
   953   1023     tputs $test_channel [appendArgs "---- test suite files located in: \"" \
   954   1024         $test_all_path \"\n]
   955   1025   
   956   1026     tputs $test_channel [appendArgs "---- test script files located in: \"" \
   957   1027         $test_path \"\n]
   958   1028   
................................................................................
  1046   1116   
  1047   1117       #
  1048   1118       # NOTE: If the "no(mono)" variable is set (to anything) then any
  1049   1119       #       special test suite hacks for Mono will be disabled. This
  1050   1120       #       does not control or change any hacks for Mono that may
  1051   1121       #       be present in the library itself.
  1052   1122       #
  1053         -    # if {[isTestMono]} then {
         1123  +    # if {[isMono]} then {
  1054   1124       #   set no(mono) true
  1055   1125       # }
  1056   1126   
  1057   1127       ###########################################################################
  1058   1128       ######################### BEGIN Eagle Constraints #########################
  1059   1129       ###########################################################################
  1060   1130   
................................................................................
  1346   1416         #
  1347   1417         # NOTE: For tests "excel-*", "object-2.*", "object-7.1", "object-8.*",
  1348   1418         #       and "object-98.*".
  1349   1419         #
  1350   1420         checkForReferenceCountTracking $test_channel
  1351   1421       }
  1352   1422   
  1353         -    #
  1354         -    # NOTE: Has testing using the C# compiler been disabled?
  1355         -    #
  1356         -    if {![info exists no(checkForCompileCSharp)]} then {
  1357         -      checkForCompileCSharp $test_channel
  1358         -    }
  1359         -
  1360   1423       #
  1361   1424       # NOTE: Has compile/runtime option testing support been disabled?
  1362   1425       #
  1363   1426       if {![info exists no(compileOptions)]} then {
  1364   1427         #
  1365   1428         # NOTE: Has "known" compile option testing support been disabled?
  1366   1429         #
................................................................................
  1385   1448           #
  1386   1449           if {![info exists no(compileCasPolicy)]} then {
  1387   1450             #
  1388   1451             # NOTE: For tests "load-1.6" and "load-1.7".
  1389   1452             #
  1390   1453             checkForCompileOption $test_channel CAS_POLICY
  1391   1454           }
         1455  +
         1456  +        #
         1457  +        # NOTE: Has configuration support been enabled (at compile-time)?
         1458  +        #
         1459  +        if {![info exists no(compileConfiguration)]} then {
         1460  +          #
         1461  +          # NOTE: For tests "debug-1.3", "object-99.1", "object-11.4",
         1462  +          #       and "garuda-1.2".
         1463  +          #
         1464  +          checkForCompileOption $test_channel CONFIGURATION
         1465  +        }
  1392   1466   
  1393   1467           #
  1394   1468           # NOTE: Has console support been enabled (at compile-time)?
  1395   1469           #
  1396   1470           if {![info exists no(compileConsole)]} then {
  1397   1471             #
  1398   1472             # NOTE: For test "host-1.2".
................................................................................
  1489   1563           #
  1490   1564           if {![info exists no(compileApprovedVerbs)]} then {
  1491   1565             #
  1492   1566             # NOTE: For test "object-4.8".
  1493   1567             #
  1494   1568             checkForCompileOption $test_channel APPROVED_VERBS
  1495   1569           }
         1570  +
         1571  +        #
         1572  +        # NOTE: Has embedded library support been enabled (at
         1573  +        #       compile-time)?
         1574  +        #
         1575  +        if {![info exists no(compileEmbeddedLibrary)]} then {
         1576  +          #
         1577  +          # NOTE: For test "interp-1.400".
         1578  +          #
         1579  +          checkForCompileOption $test_channel EMBEDDED_LIBRARY
         1580  +        }
         1581  +
         1582  +        #
         1583  +        # NOTE: Has System.Reflection.Emit support been enabled (at
         1584  +        #       compile-time)?
         1585  +        #
         1586  +        if {![info exists no(compileEmit)]} then {
         1587  +          #
         1588  +          # NOTE: For tests "commands-1.1.*", "debug-9.1", "library-*",
         1589  +          #       "object-4.10", "object-4.11", "object-4.12",
         1590  +          #       "object-8.1??", and "perf-101.0".
         1591  +          #
         1592  +          checkForCompileOption $test_channel EMIT
         1593  +        }
         1594  +
         1595  +        #
         1596  +        # NOTE: Has .NET Standard 2.0 support been enabled (at
         1597  +        #       compile-time)?
         1598  +        #
         1599  +        if {![info exists no(compileNetStandard20)]} then {
         1600  +          #
         1601  +          # NOTE: For tests "basic-1.29.*", "basic-1.30.*", "host-1.1",
         1602  +          #       "interp-1.601", "redefine-6.2", and "sql-1.17".
         1603  +          #
         1604  +          checkForCompileOption $test_channel NET_STANDARD_20
         1605  +        }
  1496   1606   
  1497   1607           #
  1498   1608           # NOTE: Has Mono support been enabled (at compile-time)?
  1499   1609           #
  1500   1610           if {![info exists no(compileMono)]} then {
  1501   1611             #
  1502   1612             # NOTE: For test "object-4.13".
................................................................................
  1616   1726           if {![info exists no(compileSerialization)]} then {
  1617   1727             #
  1618   1728             # NOTE: For test "interp-1.10".
  1619   1729             #
  1620   1730             checkForCompileOption $test_channel SERIALIZATION
  1621   1731           }
  1622   1732   
         1733  +        #
         1734  +        # NOTE: Has remoting support been enabled (at compile-time)?
         1735  +        #
         1736  +        if {![info exists no(compileRemoting)]} then {
         1737  +          #
         1738  +          # NOTE: For tests "remotingServer-1.*".
         1739  +          #
         1740  +          checkForCompileOption $test_channel REMOTING
         1741  +        }
         1742  +
         1743  +        #
         1744  +        # NOTE: Has result size limit support been enabled (at
         1745  +        #       compile-time)?
         1746  +        #
         1747  +        if {![info exists no(compileResultLimits)]} then {
         1748  +          #
         1749  +          # NOTE: For tests "interp-1.500" and "interp-1.501".
         1750  +          #
         1751  +          checkForCompileOption $test_channel RESULT_LIMITS
         1752  +        }
         1753  +
  1623   1754           #
  1624   1755           # NOTE: Has dedicated test support been enabled (at compile-time)?
  1625   1756           #
  1626   1757           if {![info exists no(compileTest)]} then {
  1627   1758             #
  1628   1759             # NOTE: For tests "basic-1.20", "basic-1.21", "function-1.1",
  1629   1760             #       "object-2.1", "object-3.1", "object-4.1", "object-7.1",
................................................................................
  1667   1798           #
  1668   1799           # NOTE: Has GDI+ drawing support been enabled (at compile-time)?
  1669   1800           #
  1670   1801           if {![info exists no(compileDrawing)]} then {
  1671   1802             checkForCompileOption $test_channel DRAWING
  1672   1803           }
  1673   1804   
  1674         -        #
  1675         -        # NOTE: Has WinForms support been enabled (at compile-time)?
  1676         -        #
  1677         -        if {![info exists no(compileWinForms)]} then {
  1678         -          checkForCompileOption $test_channel WINFORMS
  1679         -        }
  1680         -
  1681   1805           #
  1682   1806           # NOTE: Has runtime license checking support been disabled (at
  1683   1807           #       compile-time)?  This only applies to third-party plugins
  1684   1808           #       and applications.
  1685   1809           #
  1686   1810           if {![info exists no(compileLicensing)]} then {
  1687   1811             #
................................................................................
  1711   1835             #
  1712   1836             # NOTE: This is not currently used by any tests.
  1713   1837             #
  1714   1838             checkForCompileOption $test_channel DEMO_EDITION
  1715   1839           }
  1716   1840         }
  1717   1841       }
         1842  +
         1843  +    #
         1844  +    # NOTE: Has testing using the C# compiler been disabled?
         1845  +    #
         1846  +    if {![info exists no(checkForCompileCSharp)]} then {
         1847  +      checkForCompileCSharp $test_channel
         1848  +    }
  1718   1849   
  1719   1850       #
  1720   1851       # NOTE: Has dynamic loading testing support been disabled?
  1721   1852       #
  1722   1853       if {![info exists no(dynamic)]} then {
  1723   1854         #
  1724   1855         # NOTE: For tests "commands-1.1.*", "library-3.*", and "tcl*-*.*".
................................................................................
  1935   2066               *TestCallDynamicCallback1*
  1936   2067   
  1937   2068           checkForObjectMember $test_channel Eagle._Tests.Default \
  1938   2069               *TestCallDynamicCallback2*
  1939   2070   
  1940   2071           checkForObjectMember $test_channel Eagle._Tests.Default \
  1941   2072               *TestCallDynamicCallback3*
         2073  +
         2074  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         2075  +            *TestCallDynamicCallback4*
  1942   2076   
  1943   2077           checkForObjectMember $test_channel Eagle._Tests.Default \
  1944   2078               *TestGetDynamicCallbacks*
  1945   2079   
  1946   2080           checkForObjectMember $test_channel Eagle._Tests.Default \
  1947   2081               *TestCallStaticDynamicCallback0*
  1948   2082   
................................................................................
  1950   2084               *TestCallStaticDynamicCallback1*
  1951   2085   
  1952   2086           checkForObjectMember $test_channel Eagle._Tests.Default \
  1953   2087               *TestCallStaticDynamicCallback2*
  1954   2088   
  1955   2089           checkForObjectMember $test_channel Eagle._Tests.Default \
  1956   2090               *TestCallStaticDynamicCallback3*
         2091  +
         2092  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         2093  +            *TestCallStaticDynamicCallback4*
  1957   2094   
  1958   2095           checkForObjectMember $test_channel Eagle._Tests.Default \
  1959   2096               *TestGetStaticDynamicCallbacks*
  1960   2097         }
  1961   2098   
  1962   2099         #
  1963   2100         # NOTE: Has DateTime testing support been disabled?
................................................................................
  2084   2221           #
  2085   2222           # NOTE: This is not currently used by any tests.
  2086   2223           #
  2087   2224           checkForObjectMember $test_channel Eagle._Tests.Default \
  2088   2225               *TestSetComplain*
  2089   2226         }
  2090   2227   
         2228  +      #
         2229  +      # NOTE: Has special variable testing support been disabled?
         2230  +      #
         2231  +      if {![info exists no(testSetVariable)]} then {
         2232  +        #
         2233  +        # NOTE: For test "basic-1.107".
         2234  +        #
         2235  +        checkForObjectMember $test_channel Eagle._Tests.Default \
         2236  +            *TestSetVariableWithTypedValue*
         2237  +      }
         2238  +
  2091   2239         #
  2092   2240         # NOTE: Has enumerable variable testing support been disabled?
  2093   2241         #
  2094   2242         if {![info exists no(testEnumerableVariables)]} then {
  2095   2243           #
  2096   2244           # NOTE: For test "basic-1.105".
  2097   2245           #
................................................................................
  2187   2335           checkForObjectMember $test_channel Eagle._Tests.Default \
  2188   2336               *TestSaveObjects*
  2189   2337   
  2190   2338           checkForObjectMember $test_channel Eagle._Tests.Default \
  2191   2339               *TestRestoreObjects*
  2192   2340   
  2193   2341           #
  2194         -        # NOTE: For test "basic-1.29".
         2342  +        # NOTE: For test "basic-1.29.*".
  2195   2343           #
  2196   2344           checkForObjectMember $test_channel Eagle._Tests.Default \
  2197   2345               *TestExecuteStaticDelegates*
  2198   2346   
  2199   2347           #
  2200         -        # NOTE: For tests "basic-1.30" and "basic-1.31".
         2348  +        # NOTE: For tests "basic-1.30.*" and "basic-1.31".
  2201   2349           #
  2202   2350           checkForObjectMember $test_channel Eagle._Tests.Default \
  2203   2351               *TestExecuteDelegateCommands*
  2204   2352   
  2205   2353           #
  2206   2354           # NOTE: For test "namespace-97.10".
  2207   2355           #
................................................................................
  2438   2586   
  2439   2587           #
  2440   2588           # NOTE: For test "basic-1.75".
  2441   2589           #
  2442   2590           checkForObjectMember $test_channel Eagle._Tests.Default+Listener \
  2443   2591               * Eagle._Tests.Default.Listener
  2444   2592         }
         2593  +
         2594  +      #
         2595  +      # NOTE: Has script event thread testing support been disabled?
         2596  +      #
         2597  +      if {![info exists no(testScriptEventThread)]} then {
         2598  +        #
         2599  +        # NOTE: For test "interp-1.801".
         2600  +        #
         2601  +        checkForObjectMember $test_channel \
         2602  +            Eagle._Tests.Default+ScriptEventState \
         2603  +            *ToString* Eagle._Tests.Default.ScriptEventState.ToString
         2604  +
         2605  +        checkForObjectMember $test_channel \
         2606  +            Eagle._Tests.Default+ScriptEventThread \
         2607  +            *ToString* Eagle._Tests.Default.ScriptEventThread.ToString
         2608  +
         2609  +        checkForObjectMember $test_channel \
         2610  +            Eagle._Tests.Default+ScriptThreadClientData \
         2611  +            *ToString* Eagle._Tests.Default.ScriptThreadClientData.ToString
         2612  +
         2613  +        checkForObjectMember $test_channel \
         2614  +            Eagle._Tests.Default+ScriptTimeoutThread \
         2615  +            *ToString* Eagle._Tests.Default.ScriptTimeoutThread.ToString
         2616  +      }
  2445   2617       }
  2446   2618   
  2447   2619       #
  2448   2620       # NOTE: Has MSBuild testing support been disabled?
  2449   2621       #
  2450   2622       if {![info exists no(msBuild)]} then {
  2451   2623         #
................................................................................
  2463   2635       # NOTE: Has Excel testing support been disabled?
  2464   2636       #
  2465   2637       if {![info exists no(excel)]} then {
  2466   2638         #
  2467   2639         # NOTE: For tests "excel-*.*".
  2468   2640         #
  2469   2641         checkForAssembly $test_channel Microsoft.Office.Interop.Excel
         2642  +
         2643  +      #
         2644  +      # NOTE: Has Excel usability testing been disabled?
         2645  +      #
         2646  +      if {![info exists no(excelUsable)]} then {
         2647  +        #
         2648  +        # NOTE: For tests "excel-*.*".
         2649  +        #
         2650  +        checkForExcelUsable $test_channel
         2651  +      }
  2470   2652       }
  2471   2653   
  2472   2654       #
  2473   2655       # NOTE: Has speech testing support been disabled?
  2474   2656       #
  2475   2657       if {![info exists no(speech)]} then {
  2476   2658         #
................................................................................
  3027   3209         checkForFile $test_channel [file join $test_data_path settings.xml]
  3028   3210       }
  3029   3211   
  3030   3212       #
  3031   3213       # NOTE: For tests "load-1.1.*".
  3032   3214       #
  3033   3215       if {![info exists no(Plugin.dll)]} then {
  3034         -      checkForFile $test_channel [file join $lib_path Plugin1.0 Plugin.dll]
         3216  +      checkForFile $test_channel [file join \
         3217  +          $core_lib_path Plugin1.0 [getDotNetCoreLibPathDirectoryNameOnly \
         3218  +          Plugin1.0] Plugin.dll]
  3035   3219       }
  3036   3220   
  3037   3221       #
  3038   3222       # NOTE: For test "object-6.1".
  3039   3223       #
  3040   3224       if {![info exists no(Sample.exe)]} then {
  3041         -      checkForFile $test_channel [file join $bin_path Sample.exe]
         3225  +      checkForFile $test_channel [file join $core_bin_path Sample.exe]
  3042   3226       }
  3043   3227   
  3044   3228       #
  3045   3229       # NOTE: For test "object-4.8".
  3046   3230       #
  3047   3231       if {![info exists no(EagleCmdlets.dll)]} then {
  3048         -      checkForFile $test_channel [file join $bin_path EagleCmdlets.dll]
         3232  +      checkForFile $test_channel [file join $core_bin_path EagleCmdlets.dll]
  3049   3233       }
  3050   3234   
  3051   3235       #
  3052   3236       # NOTE: For test "object-4.10".
  3053   3237       #
  3054   3238       if {![info exists no(EagleExtensions.dll)]} then {
  3055         -      checkForFile $test_channel [file join $bin_path EagleExtensions.dll]
         3239  +      checkForFile $test_channel [file join $core_bin_path EagleExtensions.dll]
  3056   3240       }
  3057   3241   
  3058   3242       #
  3059   3243       # NOTE: For test "object-4.10".
  3060   3244       #
  3061   3245       if {![info exists no(test.wxs)]} then {
  3062   3246         checkForFile $test_channel [file join $base_path Installer Tests test.wxs]
................................................................................
  3063   3247       }
  3064   3248   
  3065   3249       #
  3066   3250       # NOTE: For tests "sql-1.2", "sql-1.4", "sql-1.5", "sql-1.6", "sql-1.7",
  3067   3251       #       "sql-1.8", and "sql-1.9".
  3068   3252       #
  3069   3253       if {![info exists no(sqlite3.dll)]} then {
  3070         -      checkForFile $test_channel [file join $bin_path sqlite3.dll]
         3254  +      checkForFile $test_channel [file join $core_bin_path sqlite3.dll]
  3071   3255   
  3072   3256         #
  3073   3257         # NOTE: Did we manage to find the native SQLite library?  If not, do we
  3074   3258         #       at least know the machine type?
  3075   3259         #
  3076   3260         if {![haveConstraint file_sqlite3.dll]} then {
  3077   3261           #
  3078   3262           # NOTE: Ok, now try to check for the machine specific native SQLite
  3079   3263           #       library.
  3080   3264           #
  3081         -        checkForFile $test_channel [file join $bin_path [machineToPlatform \
  3082         -            $test_machine true] sqlite3.dll]
         3265  +        checkForFile $test_channel [file join $core_bin_path \
         3266  +            [machineToPlatform $test_machine true] sqlite3.dll]
  3083   3267   
  3084   3268           #
  3085   3269           # NOTE: Did we manage to find the native SQLite library yet?
  3086   3270           #
  3087   3271           if {![haveConstraint file_sqlite3.dll]} then {
  3088   3272             #
  3089   3273             # NOTE: Ok, now try to check for the platform specific native SQLite
  3090   3274             #       library.
  3091   3275             #
  3092         -          checkForFile $test_channel [file join $bin_path [machineToPlatform \
  3093         -              $test_machine false] sqlite3.dll]
         3276  +          checkForFile $test_channel [file join $core_bin_path \
         3277  +              [machineToPlatform $test_machine false] sqlite3.dll]
  3094   3278           }
  3095   3279         }
  3096   3280       }
  3097   3281   
  3098   3282       if {![info exists no(System.Data.SQLite.dll)]} then {
  3099         -      checkForFile $test_channel [file join $bin_path System.Data.SQLite.dll]
         3283  +      checkForFile $test_channel [file join $core_bin_path \
         3284  +          System.Data.SQLite.dll]
  3100   3285       }
  3101   3286   
  3102   3287       if {![info exists no(test.sqlite3)]} then {
  3103   3288         checkForFile $test_channel [file join $test_data_path test.sqlite3]
  3104   3289       }
  3105   3290     }
  3106   3291   

Added Externals/ResGen/ResGen.exe.

cannot compute difference between binary files

Added Externals/ResGen/ResGen.exe.config.

            1  +<?xml version="1.0" encoding="UTF-8" ?>
            2  +<!--
            3  + *
            4  + * ResGen.exe.config -
            5  + *
            6  + * Copyright (c) 2007-2012 by Joe Mistachkin.  All rights reserved.
            7  + *
            8  + * See the file "license.terms" for information on usage and redistribution of
            9  + * this file, and for a DISCLAIMER OF ALL WARRANTIES.
           10  + *
           11  + * RCS: @(#) $Id: $
           12  + *
           13  +-->
           14  +<configuration>
           15  +  <startup>
           16  +    <supportedRuntime version="v2.0.50727" />
           17  +    <supportedRuntime version="v4.0.30319" />
           18  +  </startup>
           19  +
           20  +  <runtime>
           21  +    <generatePublisherEvidence enabled="false" />
           22  +  </runtime>
           23  +</configuration>

Changes to NuGet/SQLite.Core.Beta.nuspec.

    16     16       <description>This is a &quot;beta&quot; package and is not intended for production use.  The official SQLite database engine for both x86 and x64 along with the ADO.NET provider.</description>
    17     17       <language>en-US</language>
    18     18       <projectUrl>https://system.data.sqlite.org/</projectUrl>
    19     19       <iconUrl>https://system.data.sqlite.org/images/sqlite128.png</iconUrl>
    20     20       <licenseUrl>https://www.sqlite.org/copyright.html</licenseUrl>
    21     21       <tags>sqlite database ado.net provider interop</tags>
    22     22       <copyright>Public Domain</copyright>
           23  +    <dependencies>
           24  +      <group targetFramework="net20" />
           25  +      <group targetFramework="net40" />
           26  +      <group targetFramework="net45" />
           27  +      <group targetFramework="net451" />
           28  +      <group targetFramework="net46" />
           29  +      <group targetFramework="netstandard2.0" />
           30  +    </dependencies>
    23     31     </metadata>
    24     32     <files>
    25     33       <file src="..\bin\2008\Release\bin\System.Data.SQLite.dll" target="lib\net20" />
    26     34       <file src="..\bin\2008\Release\bin\System.Data.SQLite.xml" target="lib\net20" />
    27     35       <file src="..\bin\2010\Release\bin\System.Data.SQLite.dll" target="lib\net40" />
    28     36       <file src="..\bin\2010\Release\bin\System.Data.SQLite.xml" target="lib\net40" />
    29     37       <file src="..\bin\2012\Release\bin\System.Data.SQLite.dll" target="lib\net45" />
    30     38       <file src="..\bin\2012\Release\bin\System.Data.SQLite.xml" target="lib\net45" />
    31     39       <file src="..\bin\2013\Release\bin\System.Data.SQLite.dll" target="lib\net451" />
    32     40       <file src="..\bin\2013\Release\bin\System.Data.SQLite.xml" target="lib\net451" />
    33     41       <file src="..\bin\2015\Release\bin\System.Data.SQLite.dll" target="lib\net46" />
    34     42       <file src="..\bin\2015\Release\bin\System.Data.SQLite.xml" target="lib\net46" />
           43  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.dll" target="lib\netstandard2.0" />
           44  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.xml" target="lib\netstandard2.0" />
    35     45       <file src="..\bin\2008\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net20\x86" />
    36     46       <file src="..\bin\2008\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net20\x64" />
    37     47       <file src="..\bin\2010\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net40\x86" />
    38     48       <file src="..\bin\2010\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net40\x64" />
    39     49       <file src="..\bin\2012\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net45\x86" />
    40     50       <file src="..\bin\2012\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net45\x64" />
    41     51       <file src="..\bin\2013\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net451\x86" />
    42     52       <file src="..\bin\2013\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net451\x64" />
    43     53       <file src="..\bin\2015\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net46\x86" />
    44     54       <file src="..\bin\2015\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net46\x64" />
           55  +    <file src="..\bin\2015\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\netstandard2.0\x86" />
           56  +    <file src="..\bin\2015\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\netstandard2.0\x64" />
    45     57       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net20\System.Data.SQLite.Core.Beta.targets" />
    46     58       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net40\System.Data.SQLite.Core.Beta.targets" />
    47     59       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net45\System.Data.SQLite.Core.Beta.targets" />
    48     60       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net451\System.Data.SQLite.Core.Beta.targets" />
    49     61       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net46\System.Data.SQLite.Core.Beta.targets" />
           62  +    <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\netstandard2.0\System.Data.SQLite.Core.Beta.targets" />
    50     63       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net20" />
    51     64       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net40" />
    52     65       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net45" />
    53     66       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net451" />
    54     67       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net46" />
           68  +    <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\netstandard2.0" />
    55     69     </files>
    56     70   </package>

Changes to NuGet/SQLite.Core.MSIL.Beta.nuspec.

    16     16       <description>This is a &quot;beta&quot; package and is not intended for production use.  An ADO.NET provider for SQLite (managed-only).</description>
    17     17       <language>en-US</language>
    18     18       <projectUrl>https://system.data.sqlite.org/</projectUrl>
    19     19       <iconUrl>https://system.data.sqlite.org/images/sqlite128.png</iconUrl>
    20     20       <licenseUrl>https://www.sqlite.org/copyright.html</licenseUrl>
    21     21       <tags>sqlite database ado.net provider interop</tags>
    22     22       <copyright>Public Domain</copyright>
           23  +    <dependencies>
           24  +      <group targetFramework="net20" />
           25  +      <group targetFramework="net40" />
           26  +      <group targetFramework="net45" />
           27  +      <group targetFramework="net451" />
           28  +      <group targetFramework="net46" />
           29  +      <group targetFramework="netstandard2.0" />
           30  +    </dependencies>
    23     31     </metadata>
    24     32     <files>
    25     33       <file src="..\bin\2008\Release\bin\System.Data.SQLite.dll" target="lib\net20" />
    26     34       <file src="..\bin\2008\Release\bin\System.Data.SQLite.xml" target="lib\net20" />
    27     35       <file src="..\bin\2010\Release\bin\System.Data.SQLite.dll" target="lib\net40" />
    28     36       <file src="..\bin\2010\Release\bin\System.Data.SQLite.xml" target="lib\net40" />
    29     37       <file src="..\bin\2012\Release\bin\System.Data.SQLite.dll" target="lib\net45" />
    30     38       <file src="..\bin\2012\Release\bin\System.Data.SQLite.xml" target="lib\net45" />
    31     39       <file src="..\bin\2013\Release\bin\System.Data.SQLite.dll" target="lib\net451" />
    32     40       <file src="..\bin\2013\Release\bin\System.Data.SQLite.xml" target="lib\net451" />
    33     41       <file src="..\bin\2015\Release\bin\System.Data.SQLite.dll" target="lib\net46" />
    34     42       <file src="..\bin\2015\Release\bin\System.Data.SQLite.xml" target="lib\net46" />
           43  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.dll" target="lib\netstandard2.0" />
           44  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.xml" target="lib\netstandard2.0" />
    35     45     </files>
    36     46   </package>

Changes to NuGet/SQLite.Core.MSIL.Test.nuspec.

    16     16       <description>This is a pre-release package and is not intended for production use.  An ADO.NET provider for SQLite (managed-only).</description>
    17     17       <language>en-US</language>
    18     18       <projectUrl>https://system.data.sqlite.org/</projectUrl>
    19     19       <iconUrl>https://system.data.sqlite.org/images/sqlite128.png</iconUrl>
    20     20       <licenseUrl>https://www.sqlite.org/copyright.html</licenseUrl>
    21     21       <tags>sqlite database ado.net provider interop</tags>
    22     22       <copyright>Public Domain</copyright>
           23  +    <dependencies>
           24  +      <group targetFramework="net20" />
           25  +      <group targetFramework="net40" />
           26  +      <group targetFramework="net45" />
           27  +      <group targetFramework="net451" />
           28  +      <group targetFramework="net46" />
           29  +      <group targetFramework="netstandard2.0" />
           30  +    </dependencies>
    23     31     </metadata>
    24     32     <files>
    25     33       <file src="..\bin\2008\Release\bin\System.Data.SQLite.dll" target="lib\net20" />
    26     34       <file src="..\bin\2008\Release\bin\System.Data.SQLite.xml" target="lib\net20" />
    27     35       <file src="..\bin\2010\Release\bin\System.Data.SQLite.dll" target="lib\net40" />
    28     36       <file src="..\bin\2010\Release\bin\System.Data.SQLite.xml" target="lib\net40" />
    29     37       <file src="..\bin\2012\Release\bin\System.Data.SQLite.dll" target="lib\net45" />
    30     38       <file src="..\bin\2012\Release\bin\System.Data.SQLite.xml" target="lib\net45" />
    31     39       <file src="..\bin\2013\Release\bin\System.Data.SQLite.dll" target="lib\net451" />
    32     40       <file src="..\bin\2013\Release\bin\System.Data.SQLite.xml" target="lib\net451" />
    33     41       <file src="..\bin\2015\Release\bin\System.Data.SQLite.dll" target="lib\net46" />
    34     42       <file src="..\bin\2015\Release\bin\System.Data.SQLite.xml" target="lib\net46" />
           43  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.dll" target="lib\netstandard2.0" />
           44  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.xml" target="lib\netstandard2.0" />
    35     45     </files>
    36     46   </package>

Changes to NuGet/SQLite.Core.MSIL.nuspec.

    16     16       <description>An ADO.NET provider for SQLite (managed-only).</description>
    17     17       <language>en-US</language>
    18     18       <projectUrl>https://system.data.sqlite.org/</projectUrl>
    19     19       <iconUrl>https://system.data.sqlite.org/images/sqlite128.png</iconUrl>
    20     20       <licenseUrl>https://www.sqlite.org/copyright.html</licenseUrl>
    21     21       <tags>sqlite database ado.net provider interop</tags>
    22     22       <copyright>Public Domain</copyright>
           23  +    <dependencies>
           24  +      <group targetFramework="net20" />
           25  +      <group targetFramework="net40" />
           26  +      <group targetFramework="net45" />
           27  +      <group targetFramework="net451" />
           28  +      <group targetFramework="net46" />
           29  +      <group targetFramework="netstandard2.0" />
           30  +    </dependencies>
    23     31     </metadata>
    24     32     <files>
    25     33       <file src="..\bin\2008\Release\bin\System.Data.SQLite.dll" target="lib\net20" />
    26     34       <file src="..\bin\2008\Release\bin\System.Data.SQLite.xml" target="lib\net20" />
    27     35       <file src="..\bin\2010\Release\bin\System.Data.SQLite.dll" target="lib\net40" />
    28     36       <file src="..\bin\2010\Release\bin\System.Data.SQLite.xml" target="lib\net40" />
    29     37       <file src="..\bin\2012\Release\bin\System.Data.SQLite.dll" target="lib\net45" />
    30     38       <file src="..\bin\2012\Release\bin\System.Data.SQLite.xml" target="lib\net45" />
    31     39       <file src="..\bin\2013\Release\bin\System.Data.SQLite.dll" target="lib\net451" />
    32     40       <file src="..\bin\2013\Release\bin\System.Data.SQLite.xml" target="lib\net451" />
    33     41       <file src="..\bin\2015\Release\bin\System.Data.SQLite.dll" target="lib\net46" />
    34     42       <file src="..\bin\2015\Release\bin\System.Data.SQLite.xml" target="lib\net46" />
           43  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.dll" target="lib\netstandard2.0" />
           44  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.xml" target="lib\netstandard2.0" />
    35     45     </files>
    36     46   </package>

Changes to NuGet/SQLite.Core.Test.nuspec.

    16     16       <description>This is a pre-release package and is not intended for production use.  The official SQLite database engine for both x86 and x64 along with the ADO.NET provider.</description>
    17     17       <language>en-US</language>
    18     18       <projectUrl>https://system.data.sqlite.org/</projectUrl>
    19     19       <iconUrl>https://system.data.sqlite.org/images/sqlite128.png</iconUrl>
    20     20       <licenseUrl>https://www.sqlite.org/copyright.html</licenseUrl>
    21     21       <tags>sqlite database ado.net provider interop</tags>
    22     22       <copyright>Public Domain</copyright>
           23  +    <dependencies>
           24  +      <group targetFramework="net20" />
           25  +      <group targetFramework="net40" />
           26  +      <group targetFramework="net45" />
           27  +      <group targetFramework="net451" />
           28  +      <group targetFramework="net46" />
           29  +      <group targetFramework="netstandard2.0" />
           30  +    </dependencies>
    23     31     </metadata>
    24     32     <files>
    25     33       <file src="..\bin\2008\Release\bin\System.Data.SQLite.dll" target="lib\net20" />
    26     34       <file src="..\bin\2008\Release\bin\System.Data.SQLite.xml" target="lib\net20" />
    27     35       <file src="..\bin\2010\Release\bin\System.Data.SQLite.dll" target="lib\net40" />
    28     36       <file src="..\bin\2010\Release\bin\System.Data.SQLite.xml" target="lib\net40" />
    29     37       <file src="..\bin\2012\Release\bin\System.Data.SQLite.dll" target="lib\net45" />
    30     38       <file src="..\bin\2012\Release\bin\System.Data.SQLite.xml" target="lib\net45" />
    31     39       <file src="..\bin\2013\Release\bin\System.Data.SQLite.dll" target="lib\net451" />
    32     40       <file src="..\bin\2013\Release\bin\System.Data.SQLite.xml" target="lib\net451" />
    33     41       <file src="..\bin\2015\Release\bin\System.Data.SQLite.dll" target="lib\net46" />
    34     42       <file src="..\bin\2015\Release\bin\System.Data.SQLite.xml" target="lib\net46" />
           43  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.dll" target="lib\netstandard2.0" />
           44  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.xml" target="lib\netstandard2.0" />
    35     45       <file src="..\bin\2008\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net20\x86" />
    36     46       <file src="..\bin\2008\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net20\x64" />
    37     47       <file src="..\bin\2010\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net40\x86" />
    38     48       <file src="..\bin\2010\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net40\x64" />
    39     49       <file src="..\bin\2012\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net45\x86" />
    40     50       <file src="..\bin\2012\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net45\x64" />
    41     51       <file src="..\bin\2013\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net451\x86" />
    42     52       <file src="..\bin\2013\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net451\x64" />
    43     53       <file src="..\bin\2015\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net46\x86" />
    44     54       <file src="..\bin\2015\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net46\x64" />
           55  +    <file src="..\bin\2015\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\netstandard2.0\x86" />
           56  +    <file src="..\bin\2015\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\netstandard2.0\x64" />
    45     57       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net20\System.Data.SQLite.Core.Test.targets" />
    46     58       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net40\System.Data.SQLite.Core.Test.targets" />
    47     59       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net45\System.Data.SQLite.Core.Test.targets" />
    48     60       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net451\System.Data.SQLite.Core.Test.targets" />
    49     61       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net46\System.Data.SQLite.Core.Test.targets" />
           62  +    <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\netstandard2.0\System.Data.SQLite.Core.Test.targets" />
    50     63       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net20" />
    51     64       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net40" />
    52     65       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net45" />
    53     66       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net451" />
    54     67       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net46" />
           68  +    <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\netstandard2.0" />
    55     69     </files>
    56     70   </package>

Changes to NuGet/SQLite.Core.nuspec.

    16     16       <description>The official SQLite database engine for both x86 and x64 along with the ADO.NET provider.</description>
    17     17       <language>en-US</language>
    18     18       <projectUrl>https://system.data.sqlite.org/</projectUrl>
    19     19       <iconUrl>https://system.data.sqlite.org/images/sqlite128.png</iconUrl>
    20     20       <licenseUrl>https://www.sqlite.org/copyright.html</licenseUrl>
    21     21       <tags>sqlite database ado.net provider interop</tags>
    22     22       <copyright>Public Domain</copyright>
           23  +    <dependencies>
           24  +      <group targetFramework="net20" />
           25  +      <group targetFramework="net40" />
           26  +      <group targetFramework="net45" />
           27  +      <group targetFramework="net451" />
           28  +      <group targetFramework="net46" />
           29  +      <group targetFramework="netstandard2.0" />
           30  +    </dependencies>
    23     31     </metadata>
    24     32     <files>
    25     33       <file src="..\bin\2008\Release\bin\System.Data.SQLite.dll" target="lib\net20" />
    26     34       <file src="..\bin\2008\Release\bin\System.Data.SQLite.xml" target="lib\net20" />
    27     35       <file src="..\bin\2010\Release\bin\System.Data.SQLite.dll" target="lib\net40" />
    28     36       <file src="..\bin\2010\Release\bin\System.Data.SQLite.xml" target="lib\net40" />
    29     37       <file src="..\bin\2012\Release\bin\System.Data.SQLite.dll" target="lib\net45" />
    30     38       <file src="..\bin\2012\Release\bin\System.Data.SQLite.xml" target="lib\net45" />
    31     39       <file src="..\bin\2013\Release\bin\System.Data.SQLite.dll" target="lib\net451" />
    32     40       <file src="..\bin\2013\Release\bin\System.Data.SQLite.xml" target="lib\net451" />
    33     41       <file src="..\bin\2015\Release\bin\System.Data.SQLite.dll" target="lib\net46" />
    34     42       <file src="..\bin\2015\Release\bin\System.Data.SQLite.xml" target="lib\net46" />
           43  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.dll" target="lib\netstandard2.0" />
           44  +    <file src="..\bin\NetStandard20\Release\bin\System.Data.SQLite.xml" target="lib\netstandard2.0" />
    35     45       <file src="..\bin\2008\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net20\x86" />
    36     46       <file src="..\bin\2008\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net20\x64" />
    37     47       <file src="..\bin\2010\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net40\x86" />
    38     48       <file src="..\bin\2010\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net40\x64" />
    39     49       <file src="..\bin\2012\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net45\x86" />
    40     50       <file src="..\bin\2012\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net45\x64" />
    41     51       <file src="..\bin\2013\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net451\x86" />
    42     52       <file src="..\bin\2013\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net451\x64" />
    43     53       <file src="..\bin\2015\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net46\x86" />
    44     54       <file src="..\bin\2015\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\net46\x64" />
           55  +    <file src="..\bin\2015\Win32\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\netstandard2.0\x86" />
           56  +    <file src="..\bin\2015\x64\ReleaseNativeOnlyStatic\SQLite.Interop.dll" target="build\netstandard2.0\x64" />
    45     57       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net20\System.Data.SQLite.Core.targets" />
    46     58       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net40\System.Data.SQLite.Core.targets" />
    47     59       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net45\System.Data.SQLite.Core.targets" />
    48     60       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net451\System.Data.SQLite.Core.targets" />
    49     61       <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\net46\System.Data.SQLite.Core.targets" />
           62  +    <file src="shared\Core\build\System.Data.SQLite.Core.targets" target="build\netstandard2.0\System.Data.SQLite.Core.targets" />
    50     63       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net20" />
    51     64       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net40" />
    52     65       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net45" />
    53     66       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net451" />
    54     67       <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\net46" />
           68  +    <file src="shared\Core\lib\System.Data.SQLite.dll.config" target="lib\netstandard2.0" />
    55     69     </files>
    56     70   </package>

Changes to NuGet/SQLite.Linq.Beta.nuspec.

    16     16       <description>This is a &quot;beta&quot; package and is not intended for production use.  Support for LINQ using System.Data.SQLite.</description>
    17     17       <language>en-US</language>
    18     18       <projectUrl>https://system.data.sqlite.org/</projectUrl>
    19     19       <iconUrl>https://system.data.sqlite.org/images/sqlite128.png</iconUrl>
    20     20       <licenseUrl>https://www.sqlite.org/copyright.html</licenseUrl>
    21     21       <tags>sqlite database ado.net provider interop</tags>
    22     22       <copyright>Public Domain</copyright>
           23  +    <dependencies>
           24  +      <group targetFramework="net20" />
           25  +      <group targetFramework="net40" />
           26  +      <group targetFramework="net45" />
           27  +      <group targetFramework="net451" />
           28  +      <group targetFramework="net46" />
           29  +    </dependencies>
    23     30     </metadata>
    24     31     <files>
    25     32       <file src="..\bin\2008\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net20" />
    26     33       <file src="..\bin\2010\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net40" />
    27     34       <file src="..\bin\2012\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net45" />
    28     35       <file src="..\bin\2013\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net451" />
    29     36       <file src="..\bin\2015\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net46" />

Changes to NuGet/SQLite.Linq.Test.nuspec.

    16     16       <description>This is a pre-release package and is not intended for production use.  Support for LINQ using System.Data.SQLite.</description>
    17     17       <language>en-US</language>
    18     18       <projectUrl>https://system.data.sqlite.org/</projectUrl>
    19     19       <iconUrl>https://system.data.sqlite.org/images/sqlite128.png</iconUrl>
    20     20       <licenseUrl>https://www.sqlite.org/copyright.html</licenseUrl>
    21     21       <tags>sqlite database ado.net provider interop</tags>
    22     22       <copyright>Public Domain</copyright>
           23  +    <dependencies>
           24  +      <group targetFramework="net20" />
           25  +      <group targetFramework="net40" />
           26  +      <group targetFramework="net45" />
           27  +      <group targetFramework="net451" />
           28  +      <group targetFramework="net46" />
           29  +    </dependencies>
    23     30     </metadata>
    24     31     <files>
    25     32       <file src="..\bin\2008\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net20" />
    26     33       <file src="..\bin\2010\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net40" />
    27     34       <file src="..\bin\2012\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net45" />
    28     35       <file src="..\bin\2013\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net451" />
    29     36       <file src="..\bin\2015\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net46" />

Changes to NuGet/SQLite.Linq.nuspec.

    16     16       <description>Support for LINQ using System.Data.SQLite.</description>
    17     17       <language>en-US</language>
    18     18       <projectUrl>https://system.data.sqlite.org/</projectUrl>
    19     19       <iconUrl>https://system.data.sqlite.org/images/sqlite128.png</iconUrl>
    20     20       <licenseUrl>https://www.sqlite.org/copyright.html</licenseUrl>
    21     21       <tags>sqlite database ado.net provider interop</tags>
    22     22       <copyright>Public Domain</copyright>
           23  +    <dependencies>
           24  +      <group targetFramework="net20" />
           25  +      <group targetFramework="net40" />
           26  +      <group targetFramework="net45" />
           27  +      <group targetFramework="net451" />
           28  +      <group targetFramework="net46" />
           29  +    </dependencies>
    23     30     </metadata>
    24     31     <files>
    25     32       <file src="..\bin\2008\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net20" />
    26     33       <file src="..\bin\2010\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net40" />
    27     34       <file src="..\bin\2012\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net45" />
    28     35       <file src="..\bin\2013\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net451" />
    29     36       <file src="..\bin\2015\Release\bin\System.Data.SQLite.Linq.dll" target="lib\net46" />

Changes to SQLite.Interop/src/generic/interop.c.

   367    367       ret = sqlite3_config(SQLITE_CONFIG_LOG, sqlite3InteropLogCallback, 0);
   368    368       if( ret==SQLITE_OK ){
   369    369         logConfigured = 1;
   370    370       }else{
   371    371         sqlite3InteropDebug("sqlite3_config_log_interop(): sqlite3_config(SQLITE_CONFIG_LOG) returned %d.\n", ret);
   372    372       }
   373    373     }else{
   374         -    ret = SQLITE_OK;
          374  +    ret = SQLITE_DONE;
   375    375     }
   376    376     return ret;
   377    377   }
   378    378   #endif
   379    379   
   380    380   SQLITE_API const char *WINAPI interop_libversion(void)
   381    381   {

Changes to SQLite.NET.2005.MSBuild.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2005", "System.Data.SQLite\System.Data.SQLite.2005.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2005", "System.Data.SQLite\System.Data.SQLite.Module.2005.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2005.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2005", "System.Data.SQLite\System.Data.SQLite.2005.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2005", "System.Data.SQLite\System.Data.SQLite.Module.2005.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2008.MSBuild.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2008", "System.Data.SQLite\System.Data.SQLite.2008.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2008", "System.Data.SQLite\System.Data.SQLite.Module.2008.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2008.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2008", "System.Data.SQLite\System.Data.SQLite.2008.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2008", "System.Data.SQLite\System.Data.SQLite.Module.2008.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2010.MSBuild.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2010", "System.Data.SQLite\System.Data.SQLite.2010.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2010", "System.Data.SQLite\System.Data.SQLite.Module.2010.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2010.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2010", "System.Data.SQLite\System.Data.SQLite.2010.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2010", "System.Data.SQLite\System.Data.SQLite.Module.2010.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2012.MSBuild.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2012", "System.Data.SQLite\System.Data.SQLite.2012.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2012", "System.Data.SQLite\System.Data.SQLite.Module.2012.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2012.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2012", "System.Data.SQLite\System.Data.SQLite.2012.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2012", "System.Data.SQLite\System.Data.SQLite.Module.2012.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2013.MSBuild.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2013", "System.Data.SQLite\System.Data.SQLite.2013.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2013", "System.Data.SQLite\System.Data.SQLite.Module.2013.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2013.sln.

    31     31   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    32     32   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    33     33   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    34     34   		readme.htm = readme.htm
    35     35   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    36     36   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           38  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           39  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           40  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    38     41   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    39     42   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           43  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    40     44   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    41     45   	EndProjectSection
    42     46   EndProject
    43     47   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2013", "System.Data.SQLite\System.Data.SQLite.2013.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2013", "System.Data.SQLite\System.Data.SQLite.Module.2013.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    46     50   EndProject

Changes to SQLite.NET.2015.MSBuild.sln.

    33     33   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    34     34   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    35     35   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    36     36   		readme.htm = readme.htm
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    38     38   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    39     39   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           40  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           41  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           42  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    40     43   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    41     44   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           45  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    42     46   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    43     47   	EndProjectSection
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2015", "System.Data.SQLite\System.Data.SQLite.2015.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    46     50   EndProject
    47     51   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2015", "System.Data.SQLite\System.Data.SQLite.Module.2015.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    48     52   EndProject

Changes to SQLite.NET.2015.sln.

    33     33   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    34     34   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    35     35   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    36     36   		readme.htm = readme.htm
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    38     38   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    39     39   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           40  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           41  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           42  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    40     43   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    41     44   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           45  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    42     46   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    43     47   	EndProjectSection
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2015", "System.Data.SQLite\System.Data.SQLite.2015.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
    46     50   EndProject
    47     51   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2015", "System.Data.SQLite\System.Data.SQLite.Module.2015.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    48     52   EndProject

Changes to SQLite.NET.2017.MSBuild.sln.

    33     33   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    34     34   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    35     35   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    36     36   		readme.htm = readme.htm
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    38     38   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    39     39   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           40  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           41  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           42  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    40     43   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    41     44   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           45  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    42     46   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    43     47   	EndProjectSection
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2017", "System.Data.SQLite\System.Data.SQLite.2017.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
           50  +EndProject
           51  +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.NetStandard20", "System.Data.SQLite\System.Data.SQLite.NetStandard20.csproj", "{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}"
    46     52   EndProject
    47     53   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2017", "System.Data.SQLite\System.Data.SQLite.Module.2017.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    48     54   EndProject
    49     55   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Linq.2017", "System.Data.SQLite.Linq\System.Data.SQLite.Linq.2017.csproj", "{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}"
    50     56   EndProject
    51     57   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.EF6.2017", "System.Data.SQLite.Linq\System.Data.SQLite.EF6.2017.csproj", "{F1B93C04-C4AE-4D6D-B353-417AEFDCEE7B}"
    52     58   EndProject
................................................................................
   137    143   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseManagedOnly|Win32.Build.0 = Release|Any CPU
   138    144   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseManagedOnly|x64.ActiveCfg = Release|Any CPU
   139    145   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseManagedOnly|x64.Build.0 = Release|Any CPU
   140    146   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|Any CPU.ActiveCfg = Release|Any CPU
   141    147   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|Mixed Platforms.ActiveCfg = Release|Any CPU
   142    148   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|Win32.ActiveCfg = Release|Any CPU
   143    149   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|x64.ActiveCfg = Release|Any CPU
          150  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
          151  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Any CPU.Build.0 = Debug|Any CPU
          152  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
          153  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
          154  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Win32.ActiveCfg = Debug|Any CPU
          155  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Win32.Build.0 = Debug|Any CPU
          156  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|x64.ActiveCfg = Debug|Any CPU
          157  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|x64.Build.0 = Debug|Any CPU
          158  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Any CPU.ActiveCfg = Debug|Any CPU
          159  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Any CPU.Build.0 = Debug|Any CPU
          160  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Mixed Platforms.ActiveCfg = Debug|Any CPU
          161  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Mixed Platforms.Build.0 = Debug|Any CPU
          162  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Win32.ActiveCfg = Debug|Any CPU
          163  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Win32.Build.0 = Debug|Any CPU
          164  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|x64.ActiveCfg = Debug|Any CPU
          165  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|x64.Build.0 = Debug|Any CPU
          166  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Any CPU.ActiveCfg = Debug|Any CPU
          167  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Mixed Platforms.ActiveCfg = Debug|Any CPU
          168  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Win32.ActiveCfg = Debug|Any CPU
          169  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|x64.ActiveCfg = Debug|Any CPU
          170  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Any CPU.ActiveCfg = Release|Any CPU
          171  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Any CPU.Build.0 = Release|Any CPU
          172  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
          173  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Mixed Platforms.Build.0 = Release|Any CPU
          174  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Win32.ActiveCfg = Release|Any CPU
          175  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Win32.Build.0 = Release|Any CPU
          176  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|x64.ActiveCfg = Release|Any CPU
          177  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|x64.Build.0 = Release|Any CPU
          178  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Any CPU.ActiveCfg = Release|Any CPU
          179  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Any CPU.Build.0 = Release|Any CPU
          180  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Mixed Platforms.ActiveCfg = Release|Any CPU
          181  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Mixed Platforms.Build.0 = Release|Any CPU
          182  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Win32.ActiveCfg = Release|Any CPU
          183  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Win32.Build.0 = Release|Any CPU
          184  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|x64.ActiveCfg = Release|Any CPU
          185  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|x64.Build.0 = Release|Any CPU
          186  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Any CPU.ActiveCfg = Release|Any CPU
          187  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Mixed Platforms.ActiveCfg = Release|Any CPU
          188  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Win32.ActiveCfg = Release|Any CPU
          189  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|x64.ActiveCfg = Release|Any CPU
   144    190   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   145    191   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Any CPU.Build.0 = Debug|Any CPU
   146    192   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
   147    193   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
   148    194   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Win32.ActiveCfg = Debug|Any CPU
   149    195   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Win32.Build.0 = Debug|Any CPU
   150    196   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|x64.ActiveCfg = Debug|Any CPU

Changes to SQLite.NET.2017.sln.

    33     33   		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
    34     34   		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
    35     35   		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
    36     36   		readme.htm = readme.htm
    37     37   		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
    38     38   		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
    39     39   		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           40  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           41  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           42  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
    40     43   		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
    41     44   		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           45  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
    42     46   		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
    43     47   	EndProjectSection
    44     48   EndProject
    45     49   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.2017", "System.Data.SQLite\System.Data.SQLite.2017.csproj", "{AC139952-261A-4463-B6FA-AEBC25283A66}"
           50  +EndProject
           51  +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.NetStandard20", "System.Data.SQLite\System.Data.SQLite.NetStandard20.csproj", "{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}"
    46     52   EndProject
    47     53   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Module.2017", "System.Data.SQLite\System.Data.SQLite.Module.2017.csproj", "{AC139952-261A-4463-B6FA-AEBC25284A66}"
    48     54   EndProject
    49     55   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.Linq.2017", "System.Data.SQLite.Linq\System.Data.SQLite.Linq.2017.csproj", "{E6BF9F74-58E2-413B-A7CE-EA653ECB728D}"
    50     56   EndProject
    51     57   Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.EF6.2017", "System.Data.SQLite.Linq\System.Data.SQLite.EF6.2017.csproj", "{F1B93C04-C4AE-4D6D-B353-417AEFDCEE7B}"
    52     58   EndProject
................................................................................
   126    132   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|Any CPU.Build.0 = Release|Any CPU
   127    133   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|Mixed Platforms.ActiveCfg = Release|Any CPU
   128    134   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|Mixed Platforms.Build.0 = Release|Any CPU
   129    135   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|Win32.ActiveCfg = Release|Any CPU
   130    136   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|Win32.Build.0 = Release|Any CPU
   131    137   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|x64.ActiveCfg = Release|Any CPU
   132    138   		{AC139952-261A-4463-B6FA-AEBC25283A66}.ReleaseNativeOnly|x64.Build.0 = Release|Any CPU
          139  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
          140  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Any CPU.Build.0 = Debug|Any CPU
          141  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
          142  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
          143  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Win32.ActiveCfg = Debug|Any CPU
          144  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Win32.Build.0 = Debug|Any CPU
          145  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|x64.ActiveCfg = Debug|Any CPU
          146  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|x64.Build.0 = Debug|Any CPU
          147  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Any CPU.ActiveCfg = Debug|Any CPU
          148  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Any CPU.Build.0 = Debug|Any CPU
          149  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Mixed Platforms.ActiveCfg = Debug|Any CPU
          150  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Mixed Platforms.Build.0 = Debug|Any CPU
          151  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Win32.ActiveCfg = Debug|Any CPU
          152  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Win32.Build.0 = Debug|Any CPU
          153  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|x64.ActiveCfg = Debug|Any CPU
          154  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|x64.Build.0 = Debug|Any CPU
          155  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Any CPU.ActiveCfg = Release|Any CPU
          156  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Any CPU.Build.0 = Release|Any CPU
          157  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
          158  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Mixed Platforms.Build.0 = Release|Any CPU
          159  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Win32.ActiveCfg = Release|Any CPU
          160  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Win32.Build.0 = Release|Any CPU
          161  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|x64.ActiveCfg = Release|Any CPU
          162  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|x64.Build.0 = Release|Any CPU
          163  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Any CPU.ActiveCfg = Release|Any CPU
          164  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Any CPU.Build.0 = Release|Any CPU
          165  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Mixed Platforms.ActiveCfg = Release|Any CPU
          166  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Mixed Platforms.Build.0 = Release|Any CPU
          167  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Win32.ActiveCfg = Release|Any CPU
          168  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Win32.Build.0 = Release|Any CPU
          169  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|x64.ActiveCfg = Release|Any CPU
          170  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|x64.Build.0 = Release|Any CPU
   133    171   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
   134    172   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Any CPU.Build.0 = Debug|Any CPU
   135    173   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
   136    174   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
   137    175   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Win32.ActiveCfg = Debug|Any CPU
   138    176   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|Win32.Build.0 = Debug|Any CPU
   139    177   		{AC139952-261A-4463-B6FA-AEBC25284A66}.Debug|x64.ActiveCfg = Debug|Any CPU

Added SQLite.NET.NetStandard20.MSBuild.sln.

            1  +Microsoft Visual Studio Solution File, Format Version 12.00
            2  +# Visual Studio 15
            3  +VisualStudioVersion = 15.0.26430.16
            4  +MinimumVisualStudioVersion = 10.0.40219.1
            5  +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{39A3B743-1EBD-4CC0-8E37-ACE3DD38B1C0}"
            6  +	ProjectSection(SolutionItems) = preProject
            7  +		data\exclude_bin.txt = data\exclude_bin.txt
            8  +		data\exclude_src.txt = data\exclude_src.txt
            9  +		Keys\System.Data.SQLite.CF.snk = Keys\System.Data.SQLite.CF.snk
           10  +		Keys\System.Data.SQLite.snk = Keys\System.Data.SQLite.snk
           11  +		NuGet\shared\Core\build\System.Data.SQLite.Core.targets = NuGet\shared\Core\build\System.Data.SQLite.Core.targets
           12  +		NuGet\shared\Core\content\config.install.xdt = NuGet\shared\Core\content\config.install.xdt
           13  +		NuGet\shared\Core\content\config.transform = NuGet\shared\Core\content\config.transform
           14  +		NuGet\net40\EF6\content\config.transform = NuGet\net40\EF6\content\config.transform
           15  +		NuGet\net40\EF6\tools\provider.ps1 = NuGet\net40\EF6\tools\provider.ps1
           16  +		NuGet\SQLite.Core.nuspec = NuGet\SQLite.Core.nuspec
           17  +		NuGet\SQLite.Core.Beta.nuspec = NuGet\SQLite.Core.Beta.nuspec
           18  +		NuGet\SQLite.Core.Test.nuspec = NuGet\SQLite.Core.Test.nuspec
           19  +		NuGet\SQLite.Core.MSIL.nuspec = NuGet\SQLite.Core.MSIL.nuspec
           20  +		NuGet\SQLite.Core.MSIL.Beta.nuspec = NuGet\SQLite.Core.MSIL.Beta.nuspec
           21  +		NuGet\SQLite.Core.MSIL.Test.nuspec = NuGet\SQLite.Core.MSIL.Test.nuspec
           22  +		NuGet\SQLite.EF6.nuspec = NuGet\SQLite.EF6.nuspec
           23  +		NuGet\SQLite.EF6.Beta.nuspec = NuGet\SQLite.EF6.Beta.nuspec
           24  +		NuGet\SQLite.EF6.Test.nuspec = NuGet\SQLite.EF6.Test.nuspec
           25  +		NuGet\SQLite.Linq.nuspec = NuGet\SQLite.Linq.nuspec
           26  +		NuGet\SQLite.Linq.Beta.nuspec = NuGet\SQLite.Linq.Beta.nuspec
           27  +		NuGet\SQLite.Linq.Test.nuspec = NuGet\SQLite.Linq.Test.nuspec
           28  +		NuGet\SQLite.MSIL.nuspec = NuGet\SQLite.MSIL.nuspec
           29  +		NuGet\SQLite.MSIL.Beta.nuspec = NuGet\SQLite.MSIL.Beta.nuspec
           30  +		NuGet\SQLite.MSIL.Test.nuspec = NuGet\SQLite.MSIL.Test.nuspec
           31  +		NuGet\SQLite.nuspec = NuGet\SQLite.nuspec
           32  +		NuGet\SQLite.Beta.nuspec = NuGet\SQLite.Beta.nuspec
           33  +		NuGet\SQLite.Test.nuspec = NuGet\SQLite.Test.nuspec
           34  +		NuGet\SQLite.x64.nuspec = NuGet\SQLite.x64.nuspec
           35  +		NuGet\SQLite.x86.nuspec = NuGet\SQLite.x86.nuspec
           36  +		readme.htm = readme.htm
           37  +		System.Data.SQLite\Targets\System.Data.SQLite.Files.targets = System.Data.SQLite\Targets\System.Data.SQLite.Files.targets
           38  +		System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets = System.Data.SQLite\Targets\System.Data.SQLite.Properties.targets
           39  +		System.Data.SQLite\Targets\System.Data.SQLite.References.targets = System.Data.SQLite\Targets\System.Data.SQLite.References.targets
           40  +		Targets\SQLite.NET.Mono.Settings.targets = Targets\SQLite.NET.Mono.Settings.targets
           41  +		Targets\SQLite.NET.NetStandard20.Settings.targets = Targets\SQLite.NET.NetStandard20.Settings.targets
           42  +		Targets\SQLite.NET.Platform.Settings.targets = Targets\SQLite.NET.Platform.Settings.targets
           43  +		Targets\SQLite.NET.Settings.targets = Targets\SQLite.NET.Settings.targets
           44  +		Targets\SQLite.NET.Settings.targets.netFx35 = Targets\SQLite.NET.Settings.targets.netFx35
           45  +		Targets\SQLite.NET.Settings.targets.netFx40 = Targets\SQLite.NET.Settings.targets.netFx40
           46  +		Targets\SQLite.NET.targets = Targets\SQLite.NET.targets
           47  +	EndProjectSection
           48  +EndProject
           49  +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Data.SQLite.NetStandard20", "System.Data.SQLite\System.Data.SQLite.NetStandard20.csproj", "{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}"
           50  +EndProject
           51  +Global
           52  +	GlobalSection(SolutionConfigurationPlatforms) = preSolution
           53  +		Debug|Any CPU = Debug|Any CPU
           54  +		Debug|Mixed Platforms = Debug|Mixed Platforms
           55  +		Debug|Win32 = Debug|Win32
           56  +		Debug|x64 = Debug|x64
           57  +		DebugManagedOnly|Any CPU = DebugManagedOnly|Any CPU
           58  +		DebugManagedOnly|Mixed Platforms = DebugManagedOnly|Mixed Platforms
           59  +		DebugManagedOnly|Win32 = DebugManagedOnly|Win32
           60  +		DebugManagedOnly|x64 = DebugManagedOnly|x64
           61  +		DebugNativeOnly|Any CPU = DebugNativeOnly|Any CPU
           62  +		DebugNativeOnly|Mixed Platforms = DebugNativeOnly|Mixed Platforms
           63  +		DebugNativeOnly|Win32 = DebugNativeOnly|Win32
           64  +		DebugNativeOnly|x64 = DebugNativeOnly|x64
           65  +		Release|Any CPU = Release|Any CPU
           66  +		Release|Mixed Platforms = Release|Mixed Platforms
           67  +		Release|Win32 = Release|Win32
           68  +		Release|x64 = Release|x64
           69  +		ReleaseManagedOnly|Any CPU = ReleaseManagedOnly|Any CPU
           70  +		ReleaseManagedOnly|Mixed Platforms = ReleaseManagedOnly|Mixed Platforms
           71  +		ReleaseManagedOnly|Win32 = ReleaseManagedOnly|Win32
           72  +		ReleaseManagedOnly|x64 = ReleaseManagedOnly|x64
           73  +		ReleaseNativeOnly|Any CPU = ReleaseNativeOnly|Any CPU
           74  +		ReleaseNativeOnly|Mixed Platforms = ReleaseNativeOnly|Mixed Platforms
           75  +		ReleaseNativeOnly|Win32 = ReleaseNativeOnly|Win32
           76  +		ReleaseNativeOnly|x64 = ReleaseNativeOnly|x64
           77  +	EndGlobalSection
           78  +	GlobalSection(ProjectConfigurationPlatforms) = postSolution
           79  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
           80  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Any CPU.Build.0 = Debug|Any CPU
           81  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
           82  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
           83  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Win32.ActiveCfg = Debug|Any CPU
           84  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|Win32.Build.0 = Debug|Any CPU
           85  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|x64.ActiveCfg = Debug|Any CPU
           86  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Debug|x64.Build.0 = Debug|Any CPU
           87  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Any CPU.ActiveCfg = Debug|Any CPU
           88  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Any CPU.Build.0 = Debug|Any CPU
           89  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Mixed Platforms.ActiveCfg = Debug|Any CPU
           90  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Mixed Platforms.Build.0 = Debug|Any CPU
           91  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Win32.ActiveCfg = Debug|Any CPU
           92  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|Win32.Build.0 = Debug|Any CPU
           93  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|x64.ActiveCfg = Debug|Any CPU
           94  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugManagedOnly|x64.Build.0 = Debug|Any CPU
           95  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Any CPU.ActiveCfg = Debug|Any CPU
           96  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Mixed Platforms.ActiveCfg = Debug|Any CPU
           97  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|Win32.ActiveCfg = Debug|Any CPU
           98  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.DebugNativeOnly|x64.ActiveCfg = Debug|Any CPU
           99  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Any CPU.ActiveCfg = Release|Any CPU
          100  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Any CPU.Build.0 = Release|Any CPU
          101  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
          102  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Mixed Platforms.Build.0 = Release|Any CPU
          103  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Win32.ActiveCfg = Release|Any CPU
          104  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|Win32.Build.0 = Release|Any CPU
          105  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|x64.ActiveCfg = Release|Any CPU
          106  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.Release|x64.Build.0 = Release|Any CPU
          107  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Any CPU.ActiveCfg = Release|Any CPU
          108  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Any CPU.Build.0 = Release|Any CPU
          109  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Mixed Platforms.ActiveCfg = Release|Any CPU
          110  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Mixed Platforms.Build.0 = Release|Any CPU
          111  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Win32.ActiveCfg = Release|Any CPU
          112  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|Win32.Build.0 = Release|Any CPU
          113  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|x64.ActiveCfg = Release|Any CPU
          114  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseManagedOnly|x64.Build.0 = Release|Any CPU
          115  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Any CPU.ActiveCfg = Release|Any CPU
          116  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Mixed Platforms.ActiveCfg = Release|Any CPU
          117  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|Win32.ActiveCfg = Release|Any CPU
          118  +		{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}.ReleaseNativeOnly|x64.ActiveCfg = Release|Any CPU
          119  +	EndGlobalSection
          120  +	GlobalSection(SolutionProperties) = preSolution
          121  +		HideSolutionNode = FALSE
          122  +	EndGlobalSection
          123  +EndGlobal

Added Setup/build-netstandard20-debug.sh.

            1  +#!/bin/bash
            2  +
            3  +scriptdir=`dirname "$BASH_SOURCE"`
            4  +pushd "$scriptdir/.."
            5  +
            6  +dotnet build SQLite.NET.NetStandard20.MSBuild.sln /property:Configuration=Debug /property:ConfigurationSuffix=$SQLITE_NET_CONFIGURATION_SUFFIX /property:InteropCodec=false /property:InteropLog=false /property:CheckState=true /property:CountHandle=true /property:TraceConnection=true /property:TraceDetection=true /property:TraceHandle=true /property:TraceStatement=true /property:TrackMemoryBytes=true "$@"
            7  +
            8  +popd

Added Setup/build-netstandard20-release.sh.

            1  +#!/bin/bash
            2  +
            3  +scriptdir=`dirname "$BASH_SOURCE"`
            4  +pushd "$scriptdir/.."
            5  +
            6  +dotnet build SQLite.NET.NetStandard20.MSBuild.sln /property:Configuration=Release /property:ConfigurationSuffix=$SQLITE_NET_CONFIGURATION_SUFFIX /property:InteropCodec=false /property:InteropLog=false "$@"
            7  +
            8  +popd

Changes to Setup/build.bat.

   130    130   
   131    131   IF NOT DEFINED MSBUILD (
   132    132     SET MSBUILD=MSBuild.exe
   133    133   )
   134    134   
   135    135   %_VECHO% MsBuild = '%MSBUILD%'
   136    136   
          137  +IF NOT DEFINED DOTNET (
          138  +  SET DOTNET=dotnet.exe
          139  +)
          140  +
          141  +%_VECHO% DotNet = '%DOTNET%'
          142  +
   137    143   IF NOT DEFINED CSC (
   138    144     SET CSC=csc.exe
   139    145   )
   140    146   
   141    147   %_VECHO% Csc = '%CSC%'
   142    148   
   143    149   REM
   144    150   REM TODO: When the next version of Visual Studio is released, this section
   145    151   REM       may need updating.
   146    152   REM
          153  +IF DEFINED NETCORE20ONLY (
          154  +  %_AECHO% Forcing the use of the .NET Core 2.0...
          155  +  IF NOT DEFINED YEAR (
          156  +    SET YEAR=NetStandard20
          157  +  )
          158  +  CALL :fn_VerifyDotNetCore
          159  +  SET NOBUILDTOOLDIR=1
          160  +  SET USEDOTNET=1
          161  +  GOTO setup_buildToolDir
          162  +)
          163  +
   147    164   IF DEFINED NETFX20ONLY (
   148    165     %_AECHO% Forcing the use of the .NET Framework 2.0...
   149    166     SET YEAR=2005
   150    167     CALL :fn_CheckFrameworkDir v2.0.50727
   151    168     GOTO setup_buildToolDir
   152    169   )
   153    170   
................................................................................
   294    311         SET YEAR=2005
   295    312       )
   296    313     )
   297    314   )
   298    315   
   299    316   :setup_buildToolDir
   300    317   
   301         -IF DEFINED BUILDTOOLDIR (
   302         -  %_AECHO% Forcing the use of build tool directory "%BUILDTOOLDIR%"...
   303         -) ELSE (
   304         -  CALL :fn_CheckBuildToolDir
   305         -  CALL :fn_VerifyBuildToolDir
          318  +%_VECHO% NoBuildToolDir = '%NOBUILDTOOLDIR%'
          319  +%_VECHO% UseDotNet = '%USEDOTNET%'
          320  +
          321  +IF NOT DEFINED NOBUILDTOOLDIR (
          322  +  IF DEFINED BUILDTOOLDIR (
          323  +    %_AECHO% Forcing the use of build tool directory "%BUILDTOOLDIR%"...
          324  +  ) ELSE (
          325  +    CALL :fn_CheckBuildToolDir
          326  +    CALL :fn_VerifyBuildToolDir
          327  +  )
   306    328   )
   307    329   
   308    330   %_VECHO% Year = '%YEAR%'
   309    331   %_VECHO% FrameworkDir = '%FRAMEWORKDIR%'
   310    332   %_VECHO% MsBuildDir = '%MSBUILDDIR%'
   311    333   %_VECHO% VisualStudioMsBuildDir = '%VISUALSTUDIOMSBUILDDIR%'
   312    334   %_VECHO% BuildToolDir = '%BUILDTOOLDIR%'
   313    335   
   314         -IF NOT DEFINED BUILDTOOLDIR (
   315         -  ECHO.
   316         -  ECHO No directory containing MSBuild could be found.
   317         -  ECHO.
   318         -  ECHO Please install the .NET Framework or set the "FRAMEWORKDIR"
   319         -  ECHO environment variable to the location where it is installed.
   320         -  ECHO.
   321         -  GOTO errors
          336  +IF NOT DEFINED NOBUILDTOOLDIR (
          337  +  IF NOT DEFINED BUILDTOOLDIR (
          338  +    ECHO.
          339  +    ECHO No directory containing MSBuild could be found.
          340  +    ECHO.
          341  +    ECHO Please install the .NET Framework or set the "FRAMEWORKDIR"
          342  +    ECHO environment variable to the location where it is installed.
          343  +    ECHO.
          344  +    GOTO errors
          345  +  )
   322    346   )
   323    347   
   324    348   CALL :fn_ResetErrorLevel
   325    349   
   326    350   %__ECHO2% PUSHD "%ROOT%"
   327    351   
   328    352   IF ERRORLEVEL 1 (
   329    353     ECHO Could not change directory to "%ROOT%".
   330    354     GOTO errors
   331    355   )
   332    356   
   333         -CALL :fn_PrependToPath BUILDTOOLDIR
          357  +IF NOT DEFINED NOBUILDTOOLDIR (
          358  +  CALL :fn_PrependToPath BUILDTOOLDIR
          359  +)
   334    360   
   335    361   %_VECHO% Path = '%PATH%'
   336    362   
   337    363   IF NOT DEFINED SOLUTION (
   338    364     IF DEFINED COREONLY (
   339    365       %_AECHO% Building core managed project...
   340    366       SET SOLUTION=.\System.Data.SQLite\System.Data.SQLite.%YEAR%.csproj
................................................................................
   403    429   IF NOT DEFINED TEMP (
   404    430     ECHO Temporary directory must be defined.
   405    431     GOTO errors
   406    432   )
   407    433   
   408    434   %_VECHO% Temp = '%TEMP%'
   409    435   
          436  +IF NOT DEFINED LOGASM (
          437  +  IF DEFINED USEDOTNET (
          438  +    SET LOGASM=Microsoft.Build
          439  +  ) ELSE (
          440  +    SET LOGASM=Microsoft.Build.Engine
          441  +  )
          442  +)
          443  +
          444  +%_VECHO% LogAsm = '%LOGASM%'
          445  +
   410    446   IF NOT DEFINED LOGDIR (
   411    447     SET LOGDIR=%TEMP%
   412    448   )
   413    449   
   414    450   %_VECHO% LogDir = '%LOGDIR%'
   415    451   
   416    452   IF NOT DEFINED LOGPREFIX (
................................................................................
   424    460   )
   425    461   
   426    462   %_VECHO% LogSuffix = '%LOGSUFFIX%'
   427    463   
   428    464   IF DEFINED LOGGING GOTO skip_setLogging
   429    465   IF DEFINED NOLOG GOTO skip_setLogging
   430    466   
   431         -SET LOGGING="/logger:FileLogger,Microsoft.Build.Engine;Logfile=%LOGDIR%\%LOGPREFIX%_%CONFIGURATION%_%PLATFORM%_%YEAR%_%LOGSUFFIX%.log;Verbosity=diagnostic"
          467  +SET LOGGING="/logger:FileLogger,%LOGASM%;Logfile=%LOGDIR%\%LOGPREFIX%_%CONFIGURATION%_%PLATFORM%_%YEAR%_%LOGSUFFIX%.log;Verbosity=diagnostic"
          468  +
          469  +%_VECHO% Logging = '%LOGGING%'
   432    470   
   433    471   :skip_setLogging
   434    472   
   435    473   IF NOT DEFINED NOPROPS (
   436         -  IF EXIST Externals\Eagle\bin\EagleShell.exe (
          474  +  IF EXIST Externals\Eagle\bin\netFramework40\EagleShell.exe (
   437    475       IF DEFINED INTEROP_EXTRA_PROPS_FILE (
   438    476         REM
   439    477         REM HACK: This is used to work around a limitation of Visual Studio 2005
   440    478         REM       and 2008 that prevents the "InheritedPropertySheets" attribute
   441    479         REM       value from working correctly when it refers to a property that
   442    480         REM       evaluates to an empty string.
   443    481         REM
   444         -      %__ECHO% Externals\Eagle\bin\EagleShell.exe -evaluate "set fileName {SQLite.Interop/props/include.vsprops}; set data [readFile $fileName]; regsub -- {	InheritedPropertySheets=\"\"} $data {	InheritedPropertySheets=\"$^(INTEROP_EXTRA_PROPS_FILE^)\"} data; writeFile $fileName $data"
          482  +      %__ECHO% Externals\Eagle\bin\netFramework40\EagleShell.exe -evaluate "set fileName {SQLite.Interop/props/include.vsprops}; set data [readFile $fileName]; regsub -- {	InheritedPropertySheets=\"\"} $data {	InheritedPropertySheets=\"$^(INTEROP_EXTRA_PROPS_FILE^)\"} data; writeFile $fileName $data"
   445    483   
   446    484         IF ERRORLEVEL 1 (
   447    485           ECHO Property file modification of "SQLite.Interop\props\include.vsprops" failed.
   448    486           GOTO errors
   449    487         ) ELSE (
   450    488           ECHO Property file modification successful.
   451    489         )
................................................................................
   454    492       ECHO WARNING: Property file modification skipped, Eagle binaries are not available.
   455    493     )
   456    494   ) ELSE (
   457    495     ECHO WARNING: Property file modification skipped, disabled via NOPROPS environment variable.
   458    496   )
   459    497   
   460    498   IF NOT DEFINED NOTAG (
   461         -  IF EXIST Externals\Eagle\bin\EagleShell.exe (
   462         -    %__ECHO% Externals\Eagle\bin\EagleShell.exe -file Setup\sourceTag.eagle SourceIdMode SQLite.Interop\src\generic\interop.h
          499  +  IF EXIST Externals\Eagle\bin\netFramework40\EagleShell.exe (
          500  +    %__ECHO% Externals\Eagle\bin\netFramework40\EagleShell.exe -file Setup\sourceTag.eagle SourceIdMode SQLite.Interop\src\generic\interop.h
   463    501   
   464    502       IF ERRORLEVEL 1 (
   465    503         ECHO Source tagging of "SQLite.Interop\src\generic\interop.h" failed.
   466    504         GOTO errors
   467    505       )
   468    506   
   469         -    %__ECHO% Externals\Eagle\bin\EagleShell.exe -file Setup\sourceTag.eagle SourceIdMode System.Data.SQLite\SQLitePatchLevel.cs
          507  +    %__ECHO% Externals\Eagle\bin\netFramework40\EagleShell.exe -file Setup\sourceTag.eagle SourceIdMode System.Data.SQLite\SQLitePatchLevel.cs
   470    508   
   471    509       IF ERRORLEVEL 1 (
   472    510         ECHO Source tagging of "System.Data.SQLite\SQLitePatchLevel.cs" failed.
   473    511         GOTO errors
   474    512       )
   475    513     ) ELSE (
   476    514       ECHO WARNING: Source tagging skipped, Eagle binaries are not available.
................................................................................
   477    515     )
   478    516   ) ELSE (
   479    517     ECHO WARNING: Source tagging skipped, disabled via NOTAG environment variable.
   480    518   )
   481    519   
   482    520   CALL :fn_CopyVariable MSBUILD_ARGS_%BASE_CONFIGURATION% MSBUILD_ARGS_CFG
   483    521   
   484         -%_VECHO% Logging = '%LOGGING%'
          522  +IF DEFINED USEDOTNET (
          523  +  SET MSBUILD=%DOTNET%
          524  +  SET SUBCOMMANDS=build
          525  +  SET TARGET=Build
          526  +) ELSE (
          527  +  CALL :fn_UnsetVariable SUBCOMMANDS
          528  +)
          529  +
          530  +%_VECHO% MsBuild = '%MSBUILD%'
          531  +%_VECHO% SubCommands = '%SUBCOMMANDS%'
          532  +%_VECHO% Target = '%TARGET%'
   485    533   %_VECHO% BuildArgs = '%BUILD_ARGS%'
   486    534   %_VECHO% MsBuildArgs = '%MSBUILD_ARGS%'
   487    535   %_VECHO% MsBuildArgsCfg = '%MSBUILD_ARGS_CFG%'
   488    536   
   489    537   IF NOT DEFINED NOBUILD (
   490         -  %__ECHO% "%MSBUILD%" "%SOLUTION%" "/target:%TARGET%" "/property:Configuration=%MSBUILD_CONFIGURATION%" "/property:Platform=%PLATFORM%" %LOGGING% %BUILD_ARGS% %MSBUILD_ARGS% %MSBUILD_ARGS_CFG%
          538  +  %__ECHO% "%MSBUILD%" %SUBCOMMANDS% "%SOLUTION%" "/target:%TARGET%" "/property:Configuration=%MSBUILD_CONFIGURATION%" "/property:Platform=%PLATFORM%" %LOGGING% %BUILD_ARGS% %MSBUILD_ARGS% %MSBUILD_ARGS_CFG%
   491    539   
   492    540     IF ERRORLEVEL 1 (
   493    541       ECHO Build failed.
   494    542       GOTO errors
   495    543     )
   496    544   ) ELSE (
   497    545     ECHO WARNING: Build skipped, disabled via NOBUILD environment variable.
................................................................................
   702    750     IF DEFINED BUILDTOOLDIR IF NOT EXIST "%BUILDTOOLDIR%\%CSC%" IF NOT EXIST "%BUILDTOOLDIR%\Roslyn\%CSC%" (
   703    751       %_AECHO% File "%CSC%" not in build tool directory, unsetting...
   704    752       CALL :fn_UnsetVariable BUILDTOOLDIR
   705    753       GOTO :EOF
   706    754     )
   707    755     %_AECHO% Build tool directory "%BUILDTOOLDIR%" verified.
   708    756     GOTO :EOF
          757  +
          758  +:fn_VerifyDotNetCore
          759  +  FOR %%T IN (%DOTNET%) DO (
          760  +    SET %%T_PATH=%%~dp$PATH:T
          761  +  )
          762  +  IF NOT DEFINED %DOTNET%_PATH (
          763  +    ECHO The .NET Core executable "%DOTNET%" is required to be in the PATH.
          764  +    GOTO errors
          765  +  )
          766  +  GOTO :EOF
   709    767   
   710    768   :fn_UnquoteVariable
   711    769     IF NOT DEFINED %1 GOTO :EOF
   712    770     SETLOCAL
   713    771     SET __ECHO_CMD=ECHO %%%1%%
   714    772     FOR /F "delims=" %%V IN ('%__ECHO_CMD%') DO (
   715    773       SET VALUE=%%V

Changes to Setup/build_all.bat.

    63     63   )
    64     64   
    65     65   %_VECHO% Years = '%YEARS%'
    66     66   
    67     67   FOR %%C IN (%BUILD_CONFIGURATIONS%) DO (
    68     68     FOR %%P IN (%PLATFORMS%) DO (
    69     69       FOR %%Y IN (%YEARS%) DO (
    70         -      %__ECHO3% CALL "%TOOLS%\set_%%Y.bat"
           70  +      %__ECHO3% CALL "%TOOLS%\set_year_%%Y.bat"
    71     71   
    72     72         IF ERRORLEVEL 1 (
    73     73           ECHO Could not set variables for %%Y.
    74     74           GOTO errors
    75     75         )
    76     76   
    77     77         %__ECHO3% CALL "%TOOLS%\build.bat" %%C %%P

Added Setup/build_net_standard_20.bat.

            1  +@ECHO OFF
            2  +
            3  +::
            4  +:: build_net_standard_20.bat --
            5  +::
            6  +:: .NET Standard 2.0 Wrapper Tool for MSBuild
            7  +::
            8  +:: Written by Joe Mistachkin.
            9  +:: Released to the public domain, use at your own risk!
           10  +::
           11  +
           12  +SETLOCAL
           13  +
           14  +REM SET __ECHO=ECHO
           15  +REM SET __ECHO3=ECHO
           16  +IF NOT DEFINED _AECHO (SET _AECHO=REM)
           17  +IF NOT DEFINED _CECHO (SET _CECHO=REM)
           18  +IF NOT DEFINED _VECHO (SET _VECHO=REM)
           19  +
           20  +%_AECHO% Running %0 %*
           21  +
           22  +SET DUMMY2=%2
           23  +
           24  +IF DEFINED DUMMY2 (
           25  +  GOTO usage
           26  +)
           27  +
           28  +SET TOOLS=%~dp0
           29  +SET TOOLS=%TOOLS:~0,-1%
           30  +
           31  +%_VECHO% Tools = '%TOOLS%'
           32  +
           33  +SET BUILD_CONFIGURATIONS=%1
           34  +
           35  +IF DEFINED BUILD_CONFIGURATIONS (
           36  +  CALL :fn_UnquoteVariable BUILD_CONFIGURATIONS
           37  +) ELSE (
           38  +  %_AECHO% No build configurations specified, using default...
           39  +  IF DEFINED BUILD_DEBUG (
           40  +    SET BUILD_CONFIGURATIONS=DebugManagedOnly ReleaseManagedOnly
           41  +  ) ELSE (
           42  +    SET BUILD_CONFIGURATIONS=ReleaseManagedOnly
           43  +  )
           44  +)
           45  +
           46  +%_VECHO% BuildConfigurations = '%BUILD_CONFIGURATIONS%'
           47  +
           48  +SET YEARS=NetStandard20
           49  +SET PLATFORMS="Any CPU"
           50  +SET NOUSER=1
           51  +
           52  +REM
           53  +REM TODO: This list of properties must be kept synchronized with the common
           54  +REM       list in the "SQLite.NET.NetStandard20.Settings.targets" file.
           55  +REM
           56  +SET MSBUILD_ARGS=/property:ConfigurationSuffix=NetStandard20
           57  +SET MSBUILD_ARGS=%MSBUILD_ARGS% /property:InteropCodec=false
           58  +SET MSBUILD_ARGS=%MSBUILD_ARGS% /property:InteropLog=false
           59  +
           60  +IF DEFINED MSBUILD_ARGS_NET_STANDARD_20 (
           61  +  SET MSBUILD_ARGS=%MSBUILD_ARGS% %MSBUILD_ARGS_NET_STANDARD_20%
           62  +)
           63  +
           64  +REM
           65  +REM TODO: This list of properties must be kept synchronized with the debug
           66  +REM       list in the "SQLite.NET.NetStandard20.Settings.targets" file.
           67  +REM
           68  +SET MSBUILD_ARGS_DEBUG=/property:CheckState=true
           69  +SET MSBUILD_ARGS_DEBUG=%MSBUILD_ARGS_DEBUG% /property:CountHandle=true
           70  +SET MSBUILD_ARGS_DEBUG=%MSBUILD_ARGS_DEBUG% /property:TraceConnection=true
           71  +SET MSBUILD_ARGS_DEBUG=%MSBUILD_ARGS_DEBUG% /property:TraceDetection=true
           72  +SET MSBUILD_ARGS_DEBUG=%MSBUILD_ARGS_DEBUG% /property:TraceHandle=true
           73  +SET MSBUILD_ARGS_DEBUG=%MSBUILD_ARGS_DEBUG% /property:TraceStatement=true
           74  +SET MSBUILD_ARGS_DEBUG=%MSBUILD_ARGS_DEBUG% /property:TrackMemoryBytes=true
           75  +
           76  +REM
           77  +REM NOTE: For use of the .NET Core SDK build system.
           78  +REM
           79  +SET NETCORE20ONLY=1
           80  +
           81  +REM
           82  +REM NOTE: Prevent output files from being wrongly deleted.
           83  +REM
           84  +SET TARGET=Build
           85  +
           86  +%__ECHO3% CALL "%TOOLS%\build_all.bat"
           87  +
           88  +IF ERRORLEVEL 1 (
           89  +  ECHO Failed to build .NET Standard 2.0 binaries.
           90  +  GOTO errors
           91  +)
           92  +
           93  +GOTO no_errors
           94  +
           95  +:fn_UnquoteVariable
           96  +  IF NOT DEFINED %1 GOTO :EOF
           97  +  SETLOCAL
           98  +  SET __ECHO_CMD=ECHO %%%1%%
           99  +  FOR /F "delims=" %%V IN ('%__ECHO_CMD%') DO (
          100  +    SET VALUE=%%V
          101  +  )
          102  +  SET VALUE=%VALUE:"=%
          103  +  REM "
          104  +  ENDLOCAL && SET %1=%VALUE%
          105  +  GOTO :EOF
          106  +
          107  +:fn_UnsetVariable
          108  +  SETLOCAL
          109  +  SET VALUE=%1
          110  +  IF DEFINED VALUE (
          111  +    SET VALUE=
          112  +    ENDLOCAL
          113  +    SET %VALUE%=
          114  +  ) ELSE (
          115  +    ENDLOCAL
          116  +  )
          117  +  CALL :fn_ResetErrorLevel
          118  +  GOTO :EOF
          119  +
          120  +:fn_ResetErrorLevel
          121  +  VERIFY > NUL
          122  +  GOTO :EOF
          123  +
          124  +:fn_SetErrorLevel
          125  +  VERIFY MAYBE 2> NUL
          126  +  GOTO :EOF
          127  +
          128  +:usage
          129  +  ECHO.
          130  +  ECHO Usage: %~nx0 [configurations]
          131  +  ECHO.
          132  +  GOTO errors
          133  +
          134  +:errors
          135  +  CALL :fn_SetErrorLevel
          136  +  ENDLOCAL
          137  +  ECHO.
          138  +  ECHO Build failure, errors were encountered.
          139  +  GOTO end_of_file
          140  +
          141  +:no_errors
          142  +  CALL :fn_ResetErrorLevel
          143  +  ENDLOCAL
          144  +  ECHO.
          145  +  ECHO Build success, no errors were encountered.
          146  +  GOTO end_of_file
          147  +
          148  +:end_of_file
          149  +%__ECHO% EXIT /B %ERRORLEVEL%

Changes to Setup/clean.bat.

   239    239       %_AECHO%.
   240    240     )
   241    241   ) ELSE (
   242    242     %_AECHO% No files matching "%SOURCE%\Doc\SQLite.NET.chw" exist.
   243    243     %_AECHO%.
   244    244   )
   245    245   
   246         -IF EXIST "%SOURCE%\Externals\Eagle\bin\EntityFramework.*" (
   247         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\EntityFramework.*"
   248         -
   249         -  IF ERRORLEVEL 1 (
   250         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\EntityFramework.*".
   251         -    ECHO.
   252         -    GOTO errors
          246  +FOR %%D IN (netFramework40 netStandard20) DO (
          247  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\EntityFramework.*" (
          248  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\EntityFramework.*"
          249  +
          250  +    IF ERRORLEVEL 1 (
          251  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\EntityFramework.*".
          252  +      ECHO.
          253  +      GOTO errors
          254  +    ) ELSE (
          255  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\EntityFramework.*".
          256  +      %_AECHO%.
          257  +    )
          258  +  ) ELSE (
          259  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\EntityFramework.*" exist.
          260  +    %_AECHO%.
          261  +  )
          262  +
          263  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\sqlite3.*" (
          264  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\sqlite3.*"
          265  +
          266  +    IF ERRORLEVEL 1 (
          267  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\sqlite3.*".
          268  +      ECHO.
          269  +      GOTO errors
          270  +    ) ELSE (
          271  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\sqlite3.*".
          272  +      %_AECHO%.
          273  +    )
          274  +  ) ELSE (
          275  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\sqlite3.*" exist.
          276  +    %_AECHO%.
          277  +  )
          278  +
          279  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\Win32\sqlite3.*" (
          280  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\Win32\sqlite3.*"
          281  +
          282  +    IF ERRORLEVEL 1 (
          283  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\Win32\sqlite3.*".
          284  +      ECHO.
          285  +      GOTO errors
          286  +    ) ELSE (
          287  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\Win32\sqlite3.*".
          288  +      %_AECHO%.
          289  +    )
          290  +  ) ELSE (
          291  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\Win32\sqlite3.*" exist.
          292  +    %_AECHO%.
          293  +  )
          294  +
          295  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\x86\sqlite3.*" (
          296  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\x86\sqlite3.*"
          297  +
          298  +    IF ERRORLEVEL 1 (
          299  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\x86\sqlite3.*".
          300  +      ECHO.
          301  +      GOTO errors
          302  +    ) ELSE (
          303  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\x86\sqlite3.*".
          304  +      %_AECHO%.
          305  +    )
          306  +  ) ELSE (
          307  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\x86\sqlite3.*" exist.
          308  +    %_AECHO%.
          309  +  )
          310  +
          311  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\x64\sqlite3.*" (
          312  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\x64\sqlite3.*"
          313  +
          314  +    IF ERRORLEVEL 1 (
          315  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\x64\sqlite3.*".
          316  +      ECHO.
          317  +      GOTO errors
          318  +    ) ELSE (
          319  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\x64\sqlite3.*".
          320  +      %_AECHO%.
          321  +    )
          322  +  ) ELSE (
          323  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\x64\sqlite3.*" exist.
          324  +    %_AECHO%.
          325  +  )
          326  +
          327  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\SQLite.Interop.*" (
          328  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\SQLite.Interop.*"
          329  +
          330  +    IF ERRORLEVEL 1 (
          331  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\SQLite.Interop.*".
          332  +      ECHO.
          333  +      GOTO errors
          334  +    ) ELSE (
          335  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\SQLite.Interop.*".
          336  +      %_AECHO%.
          337  +    )
          338  +  ) ELSE (
          339  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\SQLite.Interop.*" exist.
          340  +    %_AECHO%.
          341  +  )
          342  +
          343  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\Win32\SQLite.Interop.*" (
          344  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\Win32\SQLite.Interop.*"
          345  +
          346  +    IF ERRORLEVEL 1 (
          347  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\Win32\SQLite.Interop.*".
          348  +      ECHO.
          349  +      GOTO errors
          350  +    ) ELSE (
          351  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\Win32\SQLite.Interop.*".
          352  +      %_AECHO%.
          353  +    )
          354  +  ) ELSE (
          355  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\Win32\SQLite.Interop.*" exist.
          356  +    %_AECHO%.
          357  +  )
          358  +
          359  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\x86\SQLite.Interop.*" (
          360  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\x86\SQLite.Interop.*"
          361  +
          362  +    IF ERRORLEVEL 1 (
          363  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\x86\SQLite.Interop.*".
          364  +      ECHO.
          365  +      GOTO errors
          366  +    ) ELSE (
          367  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\x86\SQLite.Interop.*".
          368  +      %_AECHO%.
          369  +    )
          370  +  ) ELSE (
          371  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\x86\SQLite.Interop.*" exist.
          372  +    %_AECHO%.
          373  +  )
          374  +
          375  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\x64\SQLite.Interop.*" (
          376  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\x64\SQLite.Interop.*"
          377  +
          378  +    IF ERRORLEVEL 1 (
          379  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\x64\SQLite.Interop.*".
          380  +      ECHO.
          381  +      GOTO errors
          382  +    ) ELSE (
          383  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\x64\SQLite.Interop.*".
          384  +      %_AECHO%.
          385  +    )
   253    386     ) ELSE (
   254         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\EntityFramework.*".
          387  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\x64\SQLite.Interop.*" exist.
   255    388       %_AECHO%.
   256    389     )
   257         -) ELSE (
   258         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\EntityFramework.*" exist.
   259         -  %_AECHO%.
   260         -)
   261    390   
   262         -IF EXIST "%SOURCE%\Externals\Eagle\bin\sqlite3.*" (
   263         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\sqlite3.*"
          391  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.*" (
          392  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.*"
   264    393   
   265         -  IF ERRORLEVEL 1 (
   266         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\sqlite3.*".
   267         -    ECHO.
   268         -    GOTO errors
          394  +    IF ERRORLEVEL 1 (
          395  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.*".
          396  +      ECHO.
          397  +      GOTO errors
          398  +    ) ELSE (
          399  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.*".
          400  +      %_AECHO%.
          401  +    )
   269    402     ) ELSE (
   270         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\sqlite3.*".
          403  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.*" exist.
   271    404       %_AECHO%.
   272    405     )
   273         -) ELSE (
   274         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\sqlite3.*" exist.
   275         -  %_AECHO%.
   276         -)
   277    406   
   278         -IF EXIST "%SOURCE%\Externals\Eagle\bin\Win32\sqlite3.*" (
   279         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\Win32\sqlite3.*"
          407  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.Linq.*" (
          408  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.Linq.*"
   280    409   
   281         -  IF ERRORLEVEL 1 (
   282         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\Win32\sqlite3.*".
   283         -    ECHO.
   284         -    GOTO errors
          410  +    IF ERRORLEVEL 1 (
          411  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.Linq.*".
          412  +      ECHO.
          413  +      GOTO errors
          414  +    ) ELSE (
          415  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.Linq.*".
          416  +      %_AECHO%.
          417  +    )
   285    418     ) ELSE (
   286         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\Win32\sqlite3.*".
          419  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.Linq.*" exist.
   287    420       %_AECHO%.
   288    421     )
   289         -) ELSE (
   290         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\Win32\sqlite3.*" exist.
   291         -  %_AECHO%.
   292         -)
   293    422   
   294         -IF EXIST "%SOURCE%\Externals\Eagle\bin\x86\sqlite3.*" (
   295         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\x86\sqlite3.*"
          423  +  IF EXIST "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.EF6.*" (
          424  +    %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.EF6.*"
   296    425   
   297         -  IF ERRORLEVEL 1 (
   298         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\x86\sqlite3.*".
   299         -    ECHO.
   300         -    GOTO errors
          426  +    IF ERRORLEVEL 1 (
          427  +      ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.EF6.*".
          428  +      ECHO.
          429  +      GOTO errors
          430  +    ) ELSE (
          431  +      %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.EF6.*".
          432  +      %_AECHO%.
          433  +    )
   301    434     ) ELSE (
   302         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\x86\sqlite3.*".
          435  +    %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\%%D\System.Data.SQLite.EF6.*" exist.
   303    436       %_AECHO%.
   304    437     )
   305         -) ELSE (
   306         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\x86\sqlite3.*" exist.
   307         -  %_AECHO%.
   308    438   )
   309    439   
   310         -IF EXIST "%SOURCE%\Externals\Eagle\bin\x64\sqlite3.*" (
   311         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\x64\sqlite3.*"
          440  +IF EXIST "%TEMP%\dotnet.exe.test.*.log" (
          441  +  %__ECHO% DEL /Q "%TEMP%\dotnet.exe.test.*.log"
   312    442   
   313    443     IF ERRORLEVEL 1 (
   314         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\x64\sqlite3.*".
   315         -    ECHO.
   316         -    GOTO errors
   317         -  ) ELSE (
   318         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\x64\sqlite3.*".
   319         -    %_AECHO%.
   320         -  )
   321         -) ELSE (
   322         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\x64\sqlite3.*" exist.
   323         -  %_AECHO%.
   324         -)
   325         -
   326         -IF EXIST "%SOURCE%\Externals\Eagle\bin\SQLite.Interop.*" (
   327         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\SQLite.Interop.*"
   328         -
   329         -  IF ERRORLEVEL 1 (
   330         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\SQLite.Interop.*".
   331         -    ECHO.
   332         -    GOTO errors
   333         -  ) ELSE (
   334         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\SQLite.Interop.*".
   335         -    %_AECHO%.
   336         -  )
   337         -) ELSE (
   338         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\SQLite.Interop.*" exist.
   339         -  %_AECHO%.
   340         -)
   341         -
   342         -IF EXIST "%SOURCE%\Externals\Eagle\bin\Win32\SQLite.Interop.*" (
   343         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\Win32\SQLite.Interop.*"
   344         -
   345         -  IF ERRORLEVEL 1 (
   346         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\Win32\SQLite.Interop.*".
          444  +    ECHO Could not delete "%TEMP%\dotnet.exe.test.*.log".
   347    445       ECHO.
   348    446       GOTO errors
   349    447     ) ELSE (
   350         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\Win32\SQLite.Interop.*".
          448  +    %_AECHO% Deleted "%TEMP%\dotnet.exe.test.*.log".
   351    449       %_AECHO%.
   352    450     )
   353    451   ) ELSE (
   354         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\Win32\SQLite.Interop.*" exist.
   355         -  %_AECHO%.
   356         -)
   357         -
   358         -IF EXIST "%SOURCE%\Externals\Eagle\bin\x86\SQLite.Interop.*" (
   359         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\x86\SQLite.Interop.*"
   360         -
   361         -  IF ERRORLEVEL 1 (
   362         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\x86\SQLite.Interop.*".
   363         -    ECHO.
   364         -    GOTO errors
   365         -  ) ELSE (
   366         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\x86\SQLite.Interop.*".
   367         -    %_AECHO%.
   368         -  )
   369         -) ELSE (
   370         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\x86\SQLite.Interop.*" exist.
   371         -  %_AECHO%.
   372         -)
   373         -
   374         -IF EXIST "%SOURCE%\Externals\Eagle\bin\x64\SQLite.Interop.*" (
   375         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\x64\SQLite.Interop.*"
   376         -
   377         -  IF ERRORLEVEL 1 (
   378         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\x64\SQLite.Interop.*".
   379         -    ECHO.
   380         -    GOTO errors
   381         -  ) ELSE (
   382         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\x64\SQLite.Interop.*".
   383         -    %_AECHO%.
   384         -  )
   385         -) ELSE (
   386         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\x64\SQLite.Interop.*" exist.
   387         -  %_AECHO%.
   388         -)
   389         -
   390         -IF EXIST "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.*" (
   391         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.*"
   392         -
   393         -  IF ERRORLEVEL 1 (
   394         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.*".
   395         -    ECHO.
   396         -    GOTO errors
   397         -  ) ELSE (
   398         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.*".
   399         -    %_AECHO%.
   400         -  )
   401         -) ELSE (
   402         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.*" exist.
   403         -  %_AECHO%.
   404         -)
   405         -
   406         -IF EXIST "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.Linq.*" (
   407         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.Linq.*"
   408         -
   409         -  IF ERRORLEVEL 1 (
   410         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.Linq.*".
   411         -    ECHO.
   412         -    GOTO errors
   413         -  ) ELSE (
   414         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.Linq.*".
   415         -    %_AECHO%.
   416         -  )
   417         -) ELSE (
   418         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.Linq.*" exist.
   419         -  %_AECHO%.
   420         -)
   421         -
   422         -IF EXIST "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.EF6.*" (
   423         -  %__ECHO% DEL /Q "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.EF6.*"
   424         -
   425         -  IF ERRORLEVEL 1 (
   426         -    ECHO Could not delete "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.EF6.*".
   427         -    ECHO.
   428         -    GOTO errors
   429         -  ) ELSE (
   430         -    %_AECHO% Deleted "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.EF6.*".
   431         -    %_AECHO%.
   432         -  )
   433         -) ELSE (
   434         -  %_AECHO% No files matching "%SOURCE%\Externals\Eagle\bin\System.Data.SQLite.EF6.*" exist.
          452  +  %_AECHO% No files matching "%TEMP%\dotnet.exe.test.*.log" exist.
   435    453     %_AECHO%.
   436    454   )
   437    455   
   438    456   IF EXIST "%TEMP%\EagleShell.exe.test.*.log" (
   439    457     %__ECHO% DEL /Q "%TEMP%\EagleShell.exe.test.*.log"
   440    458   
   441    459     IF ERRORLEVEL 1 (

Changes to Setup/data/verify.lst.

   206    206     Doc/SQLite.NET.hhp
   207    207     Doc/SQLite.NET.ndoc
   208    208     Doc/sync.eagle
   209    209     Doc/vtab.tcl
   210    210     Externals/
   211    211     Externals/Eagle/
   212    212     Externals/Eagle/bin/
   213         -  Externals/Eagle/bin/EagleShell.exe.config
   214         -  Externals/Eagle/bin/EagleShell.exe.mda.config
          213  +  Externals/Eagle/bin/netFramework40/
          214  +  Externals/Eagle/bin/netFramework40/EagleShell.exe.config
          215  +  Externals/Eagle/bin/netFramework40/EagleShell.exe.mda.config
   215    216     Externals/Eagle/lib/
   216    217     Externals/Eagle/lib/Eagle1.0/
   217    218     Externals/Eagle/lib/Eagle1.0/vendor.eagle
   218    219     Keys/
   219    220     Keys/System.Data.SQLite.CF.snk
   220    221     Keys/System.Data.SQLite.snk
   221    222     lib/
................................................................................
   259    260     NuGet/SQLite.x64.nuspec
   260    261     NuGet/SQLite.x86.nuspec
   261    262     readme.htm
   262    263     Setup/
   263    264     Setup/archive.bat
   264    265     Setup/bake.bat
   265    266     Setup/bake_all.bat
          267  +  Setup/build-netstandard20-debug.sh
          268  +  Setup/build-netstandard20-release.sh
   266    269     Setup/build.bat
   267    270     Setup/build_all.bat
   268    271     Setup/build_ce_200x.bat
   269    272     Setup/build_ce_2013.bat
   270    273     Setup/build_mono.bat
          274  +  Setup/build_net_standard_20.bat
   271    275     Setup/build_nuget.bat
   272    276     Setup/clean.bat
   273    277     Setup/compile-interop-assembly-debug.sh
   274    278     Setup/compile-interop-assembly-release.sh
   275    279     Setup/data/
   276    280     Setup/data/CheckForNetFx.pas
   277    281     Setup/data/InitializeSetup.pas
................................................................................
   279    283     Setup/data/verify.lst
   280    284     Setup/deployAndTestCe200x.eagle
   281    285     Setup/release.bat
   282    286     Setup/release_all.bat
   283    287     Setup/release_ce_200x.bat
   284    288     Setup/release_ce_2013.bat
   285    289     Setup/release_mono.bat
          290  +  Setup/release_net_standard_20.bat
   286    291     Setup/release_static.bat
   287    292     Setup/run-mono-tests-debug.sh
   288    293     Setup/run-mono-tests-release.sh
   289         -  Setup/set_2005.bat
   290         -  Setup/set_2008.bat
   291         -  Setup/set_2010.bat
   292         -  Setup/set_2012.bat
   293         -  Setup/set_2013.bat
   294         -  Setup/set_2015.bat
   295         -  Setup/set_2017.bat
          294  +  Setup/run-netstandard20-tests-debug.sh
          295  +  Setup/run-netstandard20-tests-release.sh
   296    296     Setup/set_common.bat
   297    297     Setup/set_Debug.bat
   298    298     Setup/set_Debug_ARMV7.bat
   299    299     "Setup/set_Debug_CEPC DevPlatform.bat"
   300    300     "Setup/set_Debug_Pocket PC 2003 (ARMV4).bat"
   301    301     Setup/set_Debug_Win32.bat
   302    302     Setup/set_Debug_x64.bat
................................................................................
   310    310     Setup/set_Debug_x86_2005.bat
   311    311     Setup/set_Debug_x86_2008.bat
   312    312     Setup/set_Debug_x86_2010.bat
   313    313     Setup/set_Debug_x86_2012.bat
   314    314     Setup/set_Debug_x86_2013.bat
   315    315     Setup/set_Debug_x86_2015.bat
   316    316     Setup/set_Debug_x86_2017.bat
          317  +  Setup/set_Debug_x86_NetStandard20.bat
   317    318     Setup/set_DebugNativeOnly.bat
   318    319     Setup/set_DebugNativeOnly_ARMV7.bat
   319    320     "Setup/set_DebugNativeOnly_CEPC DevPlatform.bat"
   320    321     "Setup/set_DebugNativeOnly_Pocket PC 2003 (ARMV4).bat"
   321    322     Setup/set_DebugNativeOnly_Win32.bat
   322    323     Setup/set_DebugNativeOnly_x64.bat
   323    324     Setup/set_DebugNativeOnly_x64_2005.bat
................................................................................
   330    331     Setup/set_DebugNativeOnly_x86_2005.bat
   331    332     Setup/set_DebugNativeOnly_x86_2008.bat
   332    333     Setup/set_DebugNativeOnly_x86_2010.bat
   333    334     Setup/set_DebugNativeOnly_x86_2012.bat
   334    335     Setup/set_DebugNativeOnly_x86_2013.bat
   335    336     Setup/set_DebugNativeOnly_x86_2015.bat
   336    337     Setup/set_DebugNativeOnly_x86_2017.bat
          338  +  Setup/set_DebugNativeOnly_x86_NetStandard20.bat
   337    339     Setup/set_netFx20.bat
   338    340     Setup/set_netFx35.bat
   339    341     Setup/set_netFx40.bat
   340    342     Setup/set_netFx45.bat
   341    343     Setup/set_netFx451.bat
   342    344     Setup/set_netFx452.bat
   343    345     Setup/set_netFx46.bat
   344    346     Setup/set_netFx461.bat
   345    347     Setup/set_netFx462.bat
   346    348     Setup/set_netFx47.bat
   347    349     Setup/set_netFx471.bat
          350  +  Setup/set_netStandard20.bat
   348    351     Setup/set_Release.bat
   349    352     Setup/set_Release_ARMV7.bat
   350    353     "Setup/set_Release_CEPC DevPlatform.bat"
   351    354     "Setup/set_Release_Pocket PC 2003 (ARMV4).bat"
   352    355     Setup/set_Release_Win32.bat
   353    356     Setup/set_Release_x64.bat
   354    357     Setup/set_Release_x64_2005.bat
................................................................................
   361    364     Setup/set_Release_x86_2005.bat
   362    365     Setup/set_Release_x86_2008.bat
   363    366     Setup/set_Release_x86_2010.bat
   364    367     Setup/set_Release_x86_2012.bat
   365    368     Setup/set_Release_x86_2013.bat
   366    369     Setup/set_Release_x86_2015.bat
   367    370     Setup/set_Release_x86_2017.bat
          371  +  Setup/set_Release_x86_NetStandard20.bat
   368    372     Setup/set_ReleaseNativeOnly.bat
   369    373     Setup/set_ReleaseNativeOnly_ARMV7.bat
   370    374     "Setup/set_ReleaseNativeOnly_CEPC DevPlatform.bat"
   371    375     "Setup/set_ReleaseNativeOnly_Pocket PC 2003 (ARMV4).bat"
   372    376     Setup/set_ReleaseNativeOnly_Win32.bat
   373    377     Setup/set_ReleaseNativeOnly_x64.bat
   374    378     Setup/set_ReleaseNativeOnly_x64_2005.bat
................................................................................
   381    385     Setup/set_ReleaseNativeOnly_x86_2005.bat
   382    386     Setup/set_ReleaseNativeOnly_x86_2008.bat
   383    387     Setup/set_ReleaseNativeOnly_x86_2010.bat
   384    388     Setup/set_ReleaseNativeOnly_x86_2012.bat
   385    389     Setup/set_ReleaseNativeOnly_x86_2013.bat
   386    390     Setup/set_ReleaseNativeOnly_x86_2015.bat
   387    391     Setup/set_ReleaseNativeOnly_x86_2017.bat
          392  +  Setup/set_ReleaseNativeOnly_x86_NetStandard20.bat
   388    393     Setup/set_x64_2005.bat
   389    394     Setup/set_x64_2008.bat
   390    395     Setup/set_x64_2010.bat
   391    396     Setup/set_x64_2012.bat
   392    397     Setup/set_x64_2013.bat
   393    398     Setup/set_x64_2015.bat
   394    399     Setup/set_x64_2017.bat
................................................................................
   395    400     Setup/set_x86_2005.bat
   396    401     Setup/set_x86_2008.bat
   397    402     Setup/set_x86_2010.bat
   398    403     Setup/set_x86_2012.bat
   399    404     Setup/set_x86_2013.bat
   400    405     Setup/set_x86_2015.bat
   401    406     Setup/set_x86_2017.bat
          407  +  Setup/set_x86_NetStandard20.bat
          408  +  Setup/set_year_2005.bat
          409  +  Setup/set_year_2008.bat
          410  +  Setup/set_year_2010.bat
          411  +  Setup/set_year_2012.bat
          412  +  Setup/set_year_2013.bat
          413  +  Setup/set_year_2015.bat
          414  +  Setup/set_year_2017.bat
          415  +  Setup/set_year_NetStandard20.bat
   402    416     Setup/sourceTag.eagle
   403    417     Setup/test.bat
   404    418     Setup/test_all.bat
   405    419     Setup/test_ce_200x.bat
   406    420     Setup/updateFileInfo.tcl
   407    421     Setup/verify.eagle
   408    422     Setup/vsSp.bat
................................................................................
   561    575     SQLite.NET.2012.sln
   562    576     SQLite.NET.2013.MSBuild.sln
   563    577     SQLite.NET.2013.sln
   564    578     SQLite.NET.2015.MSBuild.sln
   565    579     SQLite.NET.2015.sln
   566    580     SQLite.NET.2017.MSBuild.sln
   567    581     SQLite.NET.2017.sln
          582  +  SQLite.NET.NetStandard20.MSBuild.sln
   568    583     System.Data.SQLite.url
   569    584     System.Data.SQLite/
   570    585     System.Data.SQLite/AssemblyInfo.cs
   571    586     System.Data.SQLite/AssemblySourceIdAttribute.cs
   572    587     System.Data.SQLite/AssemblySourceTimeStampAttribute.cs
   573    588     System.Data.SQLite/Configurations/
   574    589     System.Data.SQLite/Configurations/System.Data.SQLite.dll.config
          590  +  System.Data.SQLite/Generated/
          591  +  System.Data.SQLite/Generated/SR.resources
   575    592     System.Data.SQLite/ISQLiteNativeModule.cs
   576    593     System.Data.SQLite/LINQ/
   577    594     System.Data.SQLite/LINQ/SQLiteConnection_Linq.cs
   578    595     System.Data.SQLite/LINQ/SQLiteFactory_Linq.cs
   579    596     System.Data.SQLite/Resources/
   580    597     System.Data.SQLite/Resources/DataTypes.xml
   581    598     System.Data.SQLite/Resources/MetaDataCollections.xml
................................................................................
   631    648     System.Data.SQLite/System.Data.SQLite.Module.2005.csproj
   632    649     System.Data.SQLite/System.Data.SQLite.Module.2008.csproj
   633    650     System.Data.SQLite/System.Data.SQLite.Module.2010.csproj
   634    651     System.Data.SQLite/System.Data.SQLite.Module.2012.csproj
   635    652     System.Data.SQLite/System.Data.SQLite.Module.2013.csproj
   636    653     System.Data.SQLite/System.Data.SQLite.Module.2015.csproj
   637    654     System.Data.SQLite/System.Data.SQLite.Module.2017.csproj
          655  +  System.Data.SQLite/System.Data.SQLite.NetStandard20.csproj
   638    656     System.Data.SQLite/Targets/
   639    657     System.Data.SQLite/Targets/System.Data.SQLite.Files.targets
   640    658     System.Data.SQLite/Targets/System.Data.SQLite.Properties.targets
   641    659     System.Data.SQLite/Targets/System.Data.SQLite.References.targets
   642    660     System.Data.SQLite/UnsafeNativeMethods.cs
   643    661     System.Data.SQLite.Linq/
   644    662     System.Data.SQLite.Linq/AssemblyInfo.cs
................................................................................
   693    711     System.Data.SQLite.Linq/System.Data.SQLite.Linq.2010.csproj
   694    712     System.Data.SQLite.Linq/System.Data.SQLite.Linq.2012.csproj
   695    713     System.Data.SQLite.Linq/System.Data.SQLite.Linq.2013.csproj
   696    714     System.Data.SQLite.Linq/System.Data.SQLite.Linq.2015.csproj
   697    715     System.Data.SQLite.Linq/System.Data.SQLite.Linq.2017.csproj
   698    716     Targets/
   699    717     Targets/SQLite.NET.Mono.Settings.targets
          718  +  Targets/SQLite.NET.NetStandard20.Settings.targets
   700    719     Targets/SQLite.NET.Platform.Settings.targets
   701    720     Targets/SQLite.NET.Settings.targets
   702    721     Targets/SQLite.NET.Settings.targets.netFx35
   703    722     Targets/SQLite.NET.Settings.targets.netFx40
   704    723     Targets/SQLite.NET.targets
   705    724     test/
   706    725     test/app.config
................................................................................
   939    958   ###############################################################################
   940    959   #
   941    960   # NOTE: This is the list of Eagle files that should be present in the full
   942    961   #       source code archive.  These files are needed only to run the test
   943    962   #       suite.
   944    963   #
   945    964   set sds_manifests(eagle) {
   946         -  Externals/Eagle/bin/Eagle.dll
   947         -  Externals/Eagle/bin/EagleShell.exe
   948         -  Externals/Eagle/bin/EagleShell32.exe
   949         -  Externals/Eagle/bin/x64/
   950         -  Externals/Eagle/bin/x64/Spilornis.dll
   951         -  Externals/Eagle/bin/x86/
   952         -  Externals/Eagle/bin/x86/Spilornis.dll
          965  +  Externals/Eagle/bin/netFramework40/Eagle.dll
          966  +  Externals/Eagle/bin/netFramework40/EagleShell.exe
          967  +  Externals/Eagle/bin/netFramework40/EagleShell32.exe
          968  +  Externals/Eagle/bin/netFramework40/x64/
          969  +  Externals/Eagle/bin/netFramework40/x64/Spilornis.dll
          970  +  Externals/Eagle/bin/netFramework40/x86/
          971  +  Externals/Eagle/bin/netFramework40/x86/Spilornis.dll
          972  +  Externals/Eagle/bin/netStandard20/Eagle.dll
          973  +  Externals/Eagle/bin/netStandard20/EagleShell.dll
          974  +  Externals/Eagle/bin/netStandard20/EagleShell.runtimeconfig.json
   953    975     Externals/Eagle/lib/Eagle1.0/auxiliary.eagle
   954    976     Externals/Eagle/lib/Eagle1.0/compat.eagle
   955    977     Externals/Eagle/lib/Eagle1.0/csharp.eagle
   956    978     Externals/Eagle/lib/Eagle1.0/database.eagle
   957    979     Externals/Eagle/lib/Eagle1.0/embed.eagle
   958    980     Externals/Eagle/lib/Eagle1.0/exec.eagle
   959    981     Externals/Eagle/lib/Eagle1.0/file1.eagle
................................................................................
   992   1014   #
   993   1015   # NOTE: This is the list of external files that should be present in the full
   994   1016   #       source code archive.  These files may be required by the build and/or
   995   1017   #       during release processing.  If missing, some features and/or build
   996   1018   #       options may be unavailable.
   997   1019   #
   998   1020   set sds_manifests(external) {
         1021  +  Externals/ResGen/
         1022  +  Externals/ResGen/ResGen.exe
         1023  +  Externals/ResGen/ResGen.exe.config
   999   1024     Externals/vswhere/
  1000   1025     Externals/vswhere/vswhere.exe
  1001   1026   }
  1002   1027   
  1003   1028   ###############################################################################
  1004   1029   #
  1005   1030   # NOTE: This is the list of core files that should be present in all binary

Changes to Setup/release.bat.

   184    184   
   185    185   SET EXCLUDE_BIN=@data\exclude_bin.txt
   186    186   SET PREFIX=sqlite
   187    187   
   188    188   %_VECHO% ExcludeBin = '%EXCLUDE_BIN%'
   189    189   %_VECHO% Prefix = '%PREFIX%'
   190    190   
          191  +IF DEFINED NO_RELEASE_YEAR (
          192  +  IF DEFINED NO_RELEASE_PLATFORM (
          193  +    SET RELEASE_OUTPUT_FILE=Setup\Output\%PREFIX%-%FRAMEWORK%-%TYPE%-%VERSION%.zip
          194  +  ) ELSE (
          195  +    SET RELEASE_OUTPUT_FILE=Setup\Output\%PREFIX%-%FRAMEWORK%-%TYPE%-%BASE_PLATFORM%%EXTRA_PLATFORM%-%VERSION%.zip
          196  +  )
          197  +) ELSE (
          198  +  IF DEFINED NO_RELEASE_PLATFORM (
          199  +    SET RELEASE_OUTPUT_FILE=Setup\Output\%PREFIX%-%FRAMEWORK%-%TYPE%-%YEAR%-%VERSION%.zip
          200  +  ) ELSE (
          201  +    SET RELEASE_OUTPUT_FILE=Setup\Output\%PREFIX%-%FRAMEWORK%-%TYPE%-%BASE_PLATFORM%%EXTRA_PLATFORM%-%YEAR%-%VERSION%.zip
          202  +  )
          203  +)
          204  +
          205  +%_VECHO% ReleaseOutputFile = '%RELEASE_OUTPUT_FILE%'
          206  +
   191    207   IF DEFINED BASE_CONFIGURATIONSUFFIX (
   192         -  FOR /F "delims=" %%F IN ('DIR /B /S /AD "bin\%YEAR%\%BASE_CONFIGURATION%%BASE_CONFIGURATIONSUFFIX%\bin" 2^> NUL') DO (
   193         -    %__ECHO% RMDIR /S /Q "%%F"
          208  +  IF NOT DEFINED NO_RELEASE_RMDIR (
          209  +    FOR /F "delims=" %%F IN ('DIR /B /S /AD "bin\%YEAR%\%BASE_CONFIGURATION%%BASE_CONFIGURATIONSUFFIX%\bin" 2^> NUL') DO (
          210  +      %__ECHO% RMDIR /S /Q "%%F"
          211  +    )
   194    212     )
   195         -  %__ECHO% zip.exe -v -j -r "Setup\Output\%PREFIX%-%FRAMEWORK%-%TYPE%-%BASE_PLATFORM%%EXTRA_PLATFORM%-%YEAR%-%VERSION%.zip" "bin\%YEAR%\%BASE_CONFIGURATION%%BASE_CONFIGURATIONSUFFIX%\bin" -x "%EXCLUDE_BIN%"
          213  +  %__ECHO% zip.exe -v -j -r "%RELEASE_OUTPUT_FILE%" "bin\%YEAR%\%BASE_CONFIGURATION%%BASE_CONFIGURATIONSUFFIX%\bin" -x "%EXCLUDE_BIN%"
   196    214   ) ELSE (
   197         -  FOR /F "delims=" %%F IN ('DIR /B /S /AD "bin\%YEAR%\%BASE_CONFIGURATION%\bin" 2^> NUL') DO (
   198         -    %__ECHO% RMDIR /S /Q "%%F"
          215  +  IF NOT DEFINED NO_RELEASE_RMDIR (
          216  +    FOR /F "delims=" %%F IN ('DIR /B /S /AD "bin\%YEAR%\%BASE_CONFIGURATION%\bin" 2^> NUL') DO (
          217  +      %__ECHO% RMDIR /S /Q "%%F"
          218  +    )
   199    219     )
   200         -  %__ECHO% zip.exe -v -j -r "Setup\Output\%PREFIX%-%FRAMEWORK%-%TYPE%-%BASE_PLATFORM%%EXTRA_PLATFORM%-%YEAR%-%VERSION%.zip" "bin\%YEAR%\%BASE_CONFIGURATION%\bin" -x "%EXCLUDE_BIN%"
          220  +  %__ECHO% zip.exe -v -j -r "%RELEASE_OUTPUT_FILE%" "bin\%YEAR%\%BASE_CONFIGURATION%\bin" -x "%EXCLUDE_BIN%"
   201    221   )
   202    222   
   203    223   IF DEFINED RELEASE_MANAGEDONLY GOTO skip_releaseInterop
   204    224   
   205    225   IF /I "%CONFIGURATION%" == "%BASE_CONFIGURATION%" (
   206    226     IF NOT DEFINED BASE_CONFIGURATIONSUFFIX (
   207         -    %__ECHO% zip.exe -v -d "Setup\Output\%PREFIX%-%FRAMEWORK%-%TYPE%-%BASE_PLATFORM%%EXTRA_PLATFORM%-%YEAR%-%VERSION%.zip" SQLite.Interop.*
          227  +    %__ECHO% zip.exe -v -d "%RELEASE_OUTPUT_FILE%" SQLite.Interop.*
   208    228     )
   209    229   )
   210    230   
   211         -%__ECHO% zip.exe -v -j -r "Setup\Output\%PREFIX%-%FRAMEWORK%-%TYPE%-%BASE_PLATFORM%%EXTRA_PLATFORM%-%YEAR%-%VERSION%.zip" "bin\%YEAR%\%PLATFORM%\%CONFIGURATION%%CONFIGURATIONSUFFIX%" -x "%EXCLUDE_BIN%"
          231  +%__ECHO% zip.exe -v -j -r "%RELEASE_OUTPUT_FILE%" "bin\%YEAR%\%PLATFORM%\%CONFIGURATION%%CONFIGURATIONSUFFIX%" -x "%EXCLUDE_BIN%"
   212    232   
   213    233   :skip_releaseInterop
   214    234   
   215    235   IF ERRORLEVEL 1 (
   216    236     ECHO Failed to archive binary files.
   217    237     GOTO errors
   218    238   )

Added Setup/release_net_standard_20.bat.

            1  +@ECHO OFF
            2  +
            3  +::
            4  +:: release_net_standard_20.bat --
            5  +::
            6  +:: .NET Standard 2.0 Release Tool
            7  +::
            8  +:: Written by Joe Mistachkin.
            9  +:: Released to the public domain, use at your own risk!
           10  +::
           11  +
           12  +SETLOCAL
           13  +
           14  +REM SET __ECHO=ECHO
           15  +REM SET __ECHO3=ECHO
           16  +IF NOT DEFINED _AECHO (SET _AECHO=REM)
           17  +IF NOT DEFINED _CECHO (SET _CECHO=REM)
           18  +IF NOT DEFINED _VECHO (SET _VECHO=REM)
           19  +
           20  +%_AECHO% Running %0 %*
           21  +
           22  +SET DUMMY2=%1
           23  +
           24  +IF DEFINED DUMMY2 (
           25  +  GOTO usage
           26  +)
           27  +
           28  +SET TOOLS=%~dp0
           29  +SET TOOLS=%TOOLS:~0,-1%
           30  +
           31  +%_VECHO% Tools = '%TOOLS%'
           32  +
           33  +IF DEFINED RELEASE_DEBUG (
           34  +  SET RELEASE_CONFIGURATIONS=DebugManagedOnly ReleaseManagedOnly
           35  +) ELSE (
           36  +  SET RELEASE_CONFIGURATIONS=ReleaseManagedOnly
           37  +)
           38  +
           39  +SET BASE_CONFIGURATIONSUFFIX=NetStandard20
           40  +SET YEARS=NetStandard20
           41  +SET PLATFORMS=MSIL
           42  +SET BASE_PLATFORM=NetCore20
           43  +SET NOBUNDLE=1
           44  +SET RELEASE_MANAGEDONLY=1
           45  +SET NO_RELEASE_YEAR=1
           46  +SET NO_RELEASE_PLATFORM=1
           47  +SET NO_RELEASE_RMDIR=1
           48  +
           49  +CALL :fn_ResetErrorLevel
           50  +
           51  +%__ECHO3% CALL "%TOOLS%\release_all.bat"
           52  +
           53  +IF ERRORLEVEL 1 (
           54  +  ECHO Failed to build .NET Standard 2.0 release files.
           55  +  GOTO errors
           56  +)
           57  +
           58  +GOTO no_errors
           59  +
           60  +:fn_ResetErrorLevel
           61  +  VERIFY > NUL
           62  +  GOTO :EOF
           63  +
           64  +:fn_SetErrorLevel
           65  +  VERIFY MAYBE 2> NUL
           66  +  GOTO :EOF
           67  +
           68  +:usage
           69  +  ECHO.
           70  +  ECHO Usage: %~nx0
           71  +  ECHO.
           72  +  GOTO errors
           73  +
           74  +:errors
           75  +  CALL :fn_SetErrorLevel
           76  +  ENDLOCAL
           77  +  ECHO.
           78  +  ECHO Release failure, errors were encountered.
           79  +  GOTO end_of_file
           80  +
           81  +:no_errors
           82  +  CALL :fn_ResetErrorLevel
           83  +  ENDLOCAL
           84  +  ECHO.
           85  +  ECHO Release success, no errors were encountered.
           86  +  GOTO end_of_file
           87  +
           88  +:end_of_file
           89  +%__ECHO% EXIT /B %ERRORLEVEL%

Changes to Setup/run-mono-tests-debug.sh.

     9      9   fi
    10     10   
    11     11   if [[ -z "$SQLITE_NET_YEAR" ]]; then
    12     12     SQLITE_NET_YEAR=2013
    13     13   fi
    14     14   
    15     15   pushd "$scriptdir/.."
    16         -mono Externals/Eagle/bin/EagleShell.exe -preInitialize "set root_path {$scriptdir/..}; set test_configuration Debug; set test_year $SQLITE_NET_YEAR; set build_directory {bin/$SQLITE_NET_YEAR/Debug$SQLITE_NET_CONFIGURATION_SUFFIX/bin}; set interop_assembly_file_names $libname" -initialize -postInitialize "unset no(deleteSqliteImplicitNativeFiles); unset no(copySqliteImplicitNativeFiles)" -file Tests/all.eagle "$@"
           16  +mono Externals/Eagle/bin/netFramework40/EagleShell.exe -preInitialize "set root_path {$scriptdir/..}; set test_configuration Debug; set test_year $SQLITE_NET_YEAR; set build_directory {bin/$SQLITE_NET_YEAR/Debug$SQLITE_NET_CONFIGURATION_SUFFIX/bin}; set interop_assembly_file_names $libname" -initialize -postInitialize "unset no(deleteSqliteImplicitNativeFiles); unset no(copySqliteImplicitNativeFiles)" -file Tests/all.eagle "$@"
    17     17   popd

Changes to Setup/run-mono-tests-release.sh.

     9      9   fi
    10     10   
    11     11   if [[ -z "$SQLITE_NET_YEAR" ]]; then
    12     12     SQLITE_NET_YEAR=2013
    13     13   fi
    14     14   
    15     15   pushd "$scriptdir/.."
    16         -mono Externals/Eagle/bin/EagleShell.exe -preInitialize "set root_path {$scriptdir/..}; set test_configuration Release; set test_year $SQLITE_NET_YEAR; set build_directory {bin/$SQLITE_NET_YEAR/Release$SQLITE_NET_CONFIGURATION_SUFFIX/bin}; set interop_assembly_file_names $libname" -initialize -postInitialize "unset no(deleteSqliteImplicitNativeFiles); unset no(copySqliteImplicitNativeFiles)" -file Tests/all.eagle "$@"
           16  +mono Externals/Eagle/bin/netFramework40/EagleShell.exe -preInitialize "set root_path {$scriptdir/..}; set test_configuration Release; set test_year $SQLITE_NET_YEAR; set build_directory {bin/$SQLITE_NET_YEAR/Release$SQLITE_NET_CONFIGURATION_SUFFIX/bin}; set interop_assembly_file_names $libname" -initialize -postInitialize "unset no(deleteSqliteImplicitNativeFiles); unset no(copySqliteImplicitNativeFiles)" -file Tests/all.eagle "$@"
    17     17   popd

Added Setup/run-netstandard20-tests-debug.sh.

            1  +#!/bin/bash
            2  +
            3  +scriptdir=`dirname "$BASH_SOURCE"`
            4  +
            5  +if [[ "$OSTYPE" == "darwin"* ]]; then
            6  +  libname=libSQLite.Interop.dylib
            7  +else
            8  +  libname=libSQLite.Interop.so
            9  +fi
           10  +
           11  +if [[ -z "$SQLITE_NET_YEAR" ]]; then
           12  +  SQLITE_NET_YEAR=2013
           13  +fi
           14  +
           15  +pushd "$scriptdir/.."
           16  +
           17  +SQLITE_INTEROP_DIR=bin/$SQLITE_NET_YEAR/Debug$SQLITE_NET_CONFIGURATION_SUFFIX/bin
           18  +SQLITE_INTEROP_FILE=$SQLITE_INTEROP_DIR/$libname
           19  +
           20  +if [[ -f "${SQLITE_INTEROP_FILE}" ]]; then
           21  +  cp "$SQLITE_INTEROP_FILE" "$SQLITE_INTEROP_DIR/SQLite.Interop.dll"
           22  +fi
           23  +
           24  +libname=SQLite.Interop.dll
           25  +
           26  +dotnet exec Externals/Eagle/bin/netStandard20/EagleShell.dll -preInitialize "set test_configuration Debug; set test_year NetStandard20; set test_native_year $SQLITE_NET_YEAR; set interop_assembly_file_names $libname" -initialize -postInitialize "unset no(deleteSqliteImplicitNativeFiles); unset no(copySqliteImplicitNativeFiles)" -file Tests/all.eagle "$@"
           27  +
           28  +popd

Added Setup/run-netstandard20-tests-release.sh.

            1  +#!/bin/bash
            2  +
            3  +scriptdir=`dirname "$BASH_SOURCE"`
            4  +
            5  +if [[ "$OSTYPE" == "darwin"* ]]; then
            6  +  libname=libSQLite.Interop.dylib
            7  +else
            8  +  libname=libSQLite.Interop.so
            9  +fi
           10  +
           11  +if [[ -z "$SQLITE_NET_YEAR" ]]; then
           12  +  SQLITE_NET_YEAR=2013
           13  +fi
           14  +
           15  +pushd "$scriptdir/.."
           16  +
           17  +SQLITE_INTEROP_DIR=bin/$SQLITE_NET_YEAR/Release$SQLITE_NET_CONFIGURATION_SUFFIX/bin
           18  +SQLITE_INTEROP_FILE=$SQLITE_INTEROP_DIR/$libname
           19  +
           20  +if [[ -f "${SQLITE_INTEROP_FILE}" ]]; then
           21  +  cp "$SQLITE_INTEROP_FILE" "$SQLITE_INTEROP_DIR/SQLite.Interop.dll"
           22  +fi
           23  +
           24  +libname=SQLite.Interop.dll
           25  +
           26  +dotnet exec Externals/Eagle/bin/netStandard20/EagleShell.dll -preInitialize "set test_configuration Release; set test_year NetStandard20; set test_native_year $SQLITE_NET_YEAR; set interop_assembly_file_names $libname" -initialize -postInitialize "unset no(deleteSqliteImplicitNativeFiles); unset no(copySqliteImplicitNativeFiles)" -file Tests/all.eagle "$@"
           27  +
           28  +popd

Added Setup/set_DebugNativeOnly_x86_NetStandard20.bat.

            1  +@ECHO OFF
            2  +
            3  +::
            4  +:: set_DebugNativeOnly_x86_NetStandard20.bat --
            5  +::
            6  +:: Written by Joe Mistachkin.
            7  +:: Released to the public domain, use at your own risk!
            8  +::
            9  +
           10  +SET CONFIGURATION=DebugNativeOnly
           11  +CALL "%~dp0\set_x86_NetStandard20.bat"

Added Setup/set_Debug_x86_NetStandard20.bat.

            1  +@ECHO OFF
            2  +
            3  +::
            4  +:: set_Debug_x86_NetStandard20.bat --
            5  +::
            6  +:: Written by Joe Mistachkin.
            7  +:: Released to the public domain, use at your own risk!
            8  +::
            9  +
           10  +SET CONFIGURATION=Debug
           11  +CALL "%~dp0\set_x86_NetStandard20.bat"

Added Setup/set_ReleaseNativeOnly_x86_NetStandard20.bat.

            1  +@ECHO OFF
            2  +
            3  +::
            4  +:: set_ReleaseNativeOnly_x86_NetStandard20.bat --
            5  +::
            6  +:: Written by Joe Mistachkin.
            7  +:: Released to the public domain, use at your own risk!
            8  +::
            9  +
           10  +SET CONFIGURATION=ReleaseNativeOnly
           11  +CALL "%~dp0\set_x86_NetStandard20.bat"

Added Setup/set_Release_x86_NetStandard20.bat.

            1  +@ECHO OFF
            2  +
            3  +::
            4  +:: set_Release_x86_NetStandard20.bat --
            5  +::
            6  +:: Written by Joe Mistachkin.
            7  +:: Released to the public domain, use at your own risk!
            8  +::
            9  +
           10  +SET CONFIGURATION=Release
           11  +CALL "%~dp0\set_x86_NetStandard20.bat"

Changes to Setup/set_common.bat.

    86     86     REM SET FRAMEWORK2015=netFx462
    87     87   )
    88     88   
    89     89   IF NOT DEFINED FRAMEWORK2017 (
    90     90     SET FRAMEWORK2017=netFx47
    91     91     REM SET FRAMEWORK2015=netFx471
    92     92   )
           93  +
           94  +IF NOT DEFINED FRAMEWORKNETSTANDARD20 (
           95  +  SET FRAMEWORKNETSTANDARD20=netStandard20
           96  +)
    93     97   
    94     98   IF DEFINED YEARS GOTO end_of_file
    95     99   
    96    100   IF NOT DEFINED NOVS2005 (
    97    101     IF DEFINED VS2005SP (
    98    102       SET YEARS=%YEARS% 2005
    99    103     )
................................................................................
   130    134   )
   131    135   
   132    136   IF NOT DEFINED NOVS2017 (
   133    137     IF DEFINED VS2017SP (
   134    138       SET YEARS=%YEARS% 2017
   135    139     )
   136    140   )
          141  +
          142  +IF NOT DEFINED NONETSTANDARD20 (
          143  +  SET YEARS=%YEARS% NetStandard20
          144  +)
   137    145   
   138    146   :end_of_file

Added Setup/set_netStandard20.bat.

            1  +@ECHO OFF
            2  +
            3  +::
            4  +:: set_netStandard20.bat --
            5  +::
            6  +:: Written by Joe Mistachkin.
            7  +:: Released to the public domain, use at your own risk!
            8  +::
            9  +
           10  +IF NOT DEFINED ISNETFX2 (
           11  +  SET ISNETFX2=False
           12  +)
           13  +
           14  +IF NOT DEFINED VCRUNTIME (
           15  +  SET VCRUNTIME=2017_VCU3
           16  +)
           17  +
           18  +IF NOT DEFINED CONFIGURATION (
           19  +  SET CONFIGURATION=Release
           20  +)
           21  +
           22  +IF NOT DEFINED PLATFORM (
           23  +  SET PLATFORM=Win32
           24  +)
           25  +
           26  +IF NOT DEFINED PROCESSOR (
           27  +  SET PROCESSOR=x86
           28  +)
           29  +
           30  +IF NOT DEFINED YEAR (
           31  +  SET YEAR=2017
           32  +)
           33  +
           34  +IF NOT DEFINED FRAMEWORK (
           35  +  SET FRAMEWORK=netStandard20
           36  +)
           37  +
           38  +:end_of_file

Added Setup/set_x86_NetStandard20.bat.

            1  +@ECHO OFF
            2  +
            3  +::
            4  +:: set_x86_NetStandard20.bat --
            5  +::
            6  +:: Written by Joe Mistachkin.
            7  +:: Released to the public domain, use at your own risk!
            8  +::
            9  +
           10  +SET ISNETFX2=False
           11  +SET VCRUNTIME=2017_VCU3
           12  +SET PLATFORM=Win32
           13  +SET PROCESSOR=x86
           14  +SET YEAR=NetStandard20

Name change from Setup/set_2005.bat to Setup/set_year_2005.bat.

     1      1   @ECHO OFF
     2      2   
     3      3   ::
     4         -:: set_2005.bat --
            4  +:: set_year_2005.bat --
     5      5   ::
     6      6   :: Written by Joe Mistachkin.
     7      7   :: Released to the public domain, use at your own risk!
     8      8   ::
     9      9   
           10  +SET NETCORE20ONLY=
    10     11   SET NETFX20ONLY=1
    11     12   SET NETFX35ONLY=
    12     13   SET NETFX40ONLY=
    13     14   SET NETFX45ONLY=
    14     15   SET NETFX451ONLY=
    15     16   SET NETFX452ONLY=
    16     17   SET NETFX46ONLY=

Name change from Setup/set_2008.bat to Setup/set_year_2008.bat.

     1      1   @ECHO OFF
     2      2   
     3      3   ::
     4         -:: set_2008.bat --
            4  +:: set_year_2008.bat --
     5      5   ::
     6      6   :: Written by Joe Mistachkin.
     7      7   :: Released to the public domain, use at your own risk!
     8      8   ::
     9      9   
           10  +SET NETCORE20ONLY=
    10     11   SET NETFX20ONLY=
    11     12   SET NETFX35ONLY=1
    12     13   SET NETFX40ONLY=
    13     14   SET NETFX45ONLY=
    14     15   SET NETFX451ONLY=
    15     16   SET NETFX452ONLY=
    16     17   SET NETFX46ONLY=

Name change from Setup/set_2010.bat to Setup/set_year_2010.bat.

     1      1   @ECHO OFF
     2      2   
     3      3   ::
     4         -:: set_2010.bat --
            4  +:: set_year_2010.bat --
     5      5   ::
     6      6   :: Written by Joe Mistachkin.
     7      7   :: Released to the public domain, use at your own risk!
     8      8   ::
     9      9   
           10  +SET NETCORE20ONLY=
    10     11   SET NETFX20ONLY=
    11     12   SET NETFX35ONLY=
    12     13   SET NETFX40ONLY=1
    13     14   SET NETFX45ONLY=
    14     15   SET NETFX451ONLY=
    15     16   SET NETFX452ONLY=
    16     17   SET NETFX46ONLY=

Name change from Setup/set_2012.bat to Setup/set_year_2012.bat.

     1      1   @ECHO OFF
     2      2   
     3      3   ::
     4         -:: set_2012.bat --
            4  +:: set_year_2012.bat --
     5      5   ::
     6      6   :: Written by Joe Mistachkin.
     7      7   :: Released to the public domain, use at your own risk!
     8      8   ::
     9      9   
           10  +SET NETCORE20ONLY=
    10     11   SET NETFX20ONLY=
    11     12   SET NETFX35ONLY=
    12     13   SET NETFX40ONLY=
    13     14   SET NETFX45ONLY=1
    14     15   SET NETFX451ONLY=
    15     16   SET NETFX452ONLY=
    16     17   SET NETFX46ONLY=

Name change from Setup/set_2013.bat to Setup/set_year_2013.bat.

     1      1   @ECHO OFF
     2      2   
     3      3   ::
     4         -:: set_2013.bat --
            4  +:: set_year_2013.bat --
     5      5   ::
     6      6   :: Written by Joe Mistachkin.
     7      7   :: Released to the public domain, use at your own risk!
     8      8   ::
     9      9   
           10  +SET NETCORE20ONLY=
    10     11   SET NETFX20ONLY=
    11     12   SET NETFX35ONLY=
    12     13   SET NETFX40ONLY=
    13     14   SET NETFX45ONLY=
    14     15   SET NETFX451ONLY=1
    15     16   SET NETFX452ONLY=
    16     17   SET NETFX46ONLY=

Name change from Setup/set_2015.bat to Setup/set_year_2015.bat.

     1      1   @ECHO OFF
     2      2   
     3      3   ::
     4         -:: set_2015.bat --
            4  +:: set_year_2015.bat --
     5      5   ::
     6      6   :: Written by Joe Mistachkin.
     7      7   :: Released to the public domain, use at your own risk!
     8      8   ::
     9      9   
           10  +SET NETCORE20ONLY=
    10     11   SET NETFX20ONLY=
    11     12   SET NETFX35ONLY=
    12     13   SET NETFX40ONLY=
    13     14   SET NETFX45ONLY=
    14     15   SET NETFX451ONLY=
    15     16   SET NETFX452ONLY=
    16     17   SET NETFX46ONLY=1

Name change from Setup/set_2017.bat to Setup/set_year_2017.bat.

     1      1   @ECHO OFF
     2      2   
     3      3   ::
     4         -:: set_2017.bat --
            4  +:: set_year_2017.bat --
     5      5   ::
     6      6   :: Written by Joe Mistachkin.
     7      7   :: Released to the public domain, use at your own risk!
     8      8   ::
     9      9   
           10  +SET NETCORE20ONLY=
    10     11   SET NETFX20ONLY=
    11     12   SET NETFX35ONLY=
    12     13   SET NETFX40ONLY=
    13     14   SET NETFX45ONLY=
    14     15   SET NETFX451ONLY=
    15     16   SET NETFX452ONLY=
    16     17   SET NETFX46ONLY=

Added Setup/set_year_NetStandard20.bat.

            1  +@ECHO OFF
            2  +
            3  +::
            4  +:: set_year_NetStandard20.bat --
            5  +::
            6  +:: Written by Joe Mistachkin.
            7  +:: Released to the public domain, use at your own risk!
            8  +::
            9  +
           10  +SET NETCORE20ONLY=1
           11  +SET NETFX20ONLY=
           12  +SET NETFX35ONLY=
           13  +SET NETFX40ONLY=
           14  +SET NETFX45ONLY=
           15  +SET NETFX451ONLY=
           16  +SET NETFX452ONLY=
           17  +SET NETFX46ONLY=
           18  +SET NETFX461ONLY=
           19  +SET NETFX462ONLY=
           20  +SET NETFX47ONLY=
           21  +SET NETFX471ONLY=
           22  +
           23  +VERIFY > NUL

Changes to Setup/test.bat.

    71     71     SET EAGLESHELL=EagleShell.exe
    72     72   ) ELSE (
    73     73     SET EAGLESHELL=EagleShell32.exe
    74     74   )
    75     75   
    76     76   %_VECHO% EagleShell = '%EAGLESHELL%'
    77     77   
    78         -%_CECHO% "Externals\Eagle\bin\%EAGLESHELL%" %PREARGS% %* %POSTARGS%
    79         -%__ECHO% "Externals\Eagle\bin\%EAGLESHELL%" %PREARGS% %* %POSTARGS%
           78  +%_CECHO% "Externals\Eagle\bin\netFramework40\%EAGLESHELL%" %PREARGS% %* %POSTARGS%
           79  +%__ECHO% "Externals\Eagle\bin\netFramework40\%EAGLESHELL%" %PREARGS% %* %POSTARGS%
    80     80   
    81     81   IF ERRORLEVEL 1 (
    82     82     ECHO Received non-zero return code from the Eagle Shell.
    83     83     GOTO errors
    84     84   )
    85     85   
    86     86   %__ECHO2% POPD

Changes to Setup/test_all.bat.

   139    139             IF ERRORLEVEL 1 (
   140    140               ECHO Failed to delete "bin\%%Y\%%C\bin\SQLite.Interop.*".
   141    141               GOTO errors
   142    142             )
   143    143           )
   144    144   
   145    145           IF NOT DEFINED NOMANAGEDONLY (
   146         -          %__ECHO% "Externals\Eagle\bin\%EAGLESHELL%" %PREARGS% -anyInitialize "set test_year {%%Y}; set test_configuration {%%C}" -file "%TEST_FILE%" %POSTARGS%
          146  +          %__ECHO% "Externals\Eagle\bin\netFramework40\%EAGLESHELL%" %PREARGS% -anyInitialize "set test_year {%%Y}; set test_configuration {%%C}" -file "%TEST_FILE%" %POSTARGS%
   147    147   
   148    148             IF ERRORLEVEL 1 (
   149    149               ECHO Testing of "%%Y/%%C" managed-only assembly failed.
   150    150               GOTO errors
   151    151             )
   152    152           )
   153    153   
................................................................................
   220    220   
   221    221                 IF ERRORLEVEL 1 (
   222    222                   ECHO Failed to copy "bin\%%Y\%%C\bin\Installer.*" to "bin\%%Y\%PLATFORM%\%%C".
   223    223                   GOTO errors
   224    224                 )
   225    225               )
   226    226   
   227         -            %__ECHO% "Externals\Eagle\bin\%EAGLESHELL%" %PREARGS% -preInitialize "set test_year {%%Y}; set test_configuration {%%C}" -initialize -runtimeOption native -file "%TEST_FILE%" %POSTARGS%
          227  +            %__ECHO% "Externals\Eagle\bin\netFramework40\%EAGLESHELL%" %PREARGS% -preInitialize "set test_year {%%Y}; set test_configuration {%%C}" -initialize -runtimeOption native -file "%TEST_FILE%" %POSTARGS%
   228    228   
   229    229               IF ERRORLEVEL 1 (
   230    230                 ECHO Testing of "%%Y/%%C" mixed-mode assembly failed.
   231    231                 GOTO errors
   232    232               )
   233    233             )
   234    234           ) ELSE (

Changes to Setup/test_ce_200x.bat.

    31     31   %_VECHO% Root = '%ROOT%'
    32     32   
    33     33   SET TOOLS=%~dp0
    34     34   SET TOOLS=%TOOLS:~0,-1%
    35     35   
    36     36   %_VECHO% Tools = '%TOOLS%'
    37     37   
    38         -SET EAGLEBINDIR=%ROOT%\Externals\Eagle\bin
           38  +SET EAGLEBINDIR=%ROOT%\Externals\Eagle\bin\netFramework40
    39     39   
    40     40   CALL :fn_PrependToPath EAGLEBINDIR
    41     41   
    42     42   %_VECHO% EagleBinDir = '%EAGLEBINDIR%'
    43     43   %_VECHO% Path = '%PATH%'
    44     44   
    45     45   %__ECHO3% CALL "%TOOLS%\vsSp.bat"

Changes to System.Data.SQLite/Configurations/System.Data.SQLite.dll.config.

   140    140                         does not make any sense to use it here as it will never
   141    141                         be consulted.  For this setting to work properly, it must
   142    142                         be set via an environment variable.
   143    143       -->
   144    144       <!--
   145    145       <add key="No_SQLiteXmlConfigFile" value="1" />
   146    146       -->
          147  +
          148  +    <!--
          149  +        NOTE: If this configuration variable is set [to anything], the base
          150  +              directory itself is considered valid for pre-loading the native
          151  +              SQLite library.
          152  +    -->
          153  +    <!--
          154  +    <add key="PreLoadSQLite_AllowBaseDirectoryOnly" value="1" />
          155  +    -->
   147    156   
   148    157       <!--
   149    158           NOTE: If this configuration variable is set [to anything], it will be
   150    159                 used instead of the application base directory by the native
   151    160                 library pre-loader.  This environment variable can be especially
   152    161                 useful in ASP.NET and other hosted environments where direct
   153    162                 control of the location of the managed assemblies is not under

Added System.Data.SQLite/Generated/SR.resources.

cannot compute difference between binary files

Changes to System.Data.SQLite/LINQ/SQLiteFactory_Linq.cs.

    40     40       static SQLiteFactory()
    41     41       {
    42     42   #if (SQLITE_STANDARD || USE_INTEROP_DLL || PLATFORM_COMPACTFRAMEWORK) && PRELOAD_NATIVE_LIBRARY
    43     43           UnsafeNativeMethods.Initialize();
    44     44   #endif
    45     45   
    46     46   #if USE_INTEROP_DLL && INTEROP_LOG
    47         -        if (UnsafeNativeMethods.sqlite3_config_log_interop() == SQLiteErrorCode.Ok)
           47  +        SQLiteErrorCode rc = UnsafeNativeMethods.sqlite3_config_log_interop();
           48  +
           49  +        if (rc == SQLiteErrorCode.Ok)
    48     50           {
    49     51               UnsafeNativeMethods.sqlite3_log(
    50         -                SQLiteErrorCode.Ok, SQLiteConvert.ToUTF8("logging initialized."));
           52  +                rc, SQLiteConvert.ToUTF8("logging initialized via SQLiteFactory."));
    51     53           }
    52     54   #endif
    53     55   
    54     56           SQLiteLog.Initialize();
    55     57   
    56     58           string version =
    57     59   #if NET_40 || NET_45 || NET_451 || NET_452 || NET_46 || NET_461 || NET_462 || NET_47 || NET_471
................................................................................
    74     76           (_dbProviderServicesType != null && serviceType == _dbProviderServicesType))
    75     77         {
    76     78           return GetSQLiteProviderServicesInstance();
    77     79         }
    78     80         return null;
    79     81       }
    80     82   
           83  +#if !NET_STANDARD_20
    81     84       [ReflectionPermission(SecurityAction.Assert, MemberAccess = true)]
           85  +#endif
    82     86       private object GetSQLiteProviderServicesInstance()
    83     87       {
    84     88           if (_sqliteServices == null)
    85     89           {
    86     90               string typeName = UnsafeNativeMethods.GetSettingValue(
    87     91                   "TypeName_SQLiteProviderServices", null);
    88     92   

Changes to System.Data.SQLite/SQLiteConnection.cs.

  1789   1789                 if (_versionNumber >= 3007014)
  1790   1790                     SQLiteConnectionHandle.closeConnection = SQLiteBase.CloseConnectionV2;
  1791   1791             }
  1792   1792         }
  1793   1793   #endif
  1794   1794   
  1795   1795   #if USE_INTEROP_DLL && INTEROP_LOG
  1796         -      if (UnsafeNativeMethods.sqlite3_config_log_interop() == SQLiteErrorCode.Ok)
         1796  +      SQLiteErrorCode rc = UnsafeNativeMethods.sqlite3_config_log_interop();
         1797  +
         1798  +      if (rc == SQLiteErrorCode.Ok)
  1797   1799         {
  1798   1800             UnsafeNativeMethods.sqlite3_log(
  1799         -              SQLiteErrorCode.Ok, SQLiteConvert.ToUTF8("logging initialized."));
         1801  +              rc, SQLiteConvert.ToUTF8("logging initialized via SQLiteConnection."));
  1800   1802         }
  1801   1803   #endif
  1802   1804   
  1803   1805         _cachedSettings = new Dictionary<string, object>(
  1804   1806             new TypeNameStringComparer());
  1805   1807   
  1806   1808         _typeNames = new SQLiteDbTypeMap();

Changes to System.Data.SQLite/SQLiteDefineConstants.cs.

   139    139   #if NET_471
   140    140               "NET_471",
   141    141   #endif
   142    142   
   143    143   #if NET_COMPACT_20
   144    144               "NET_COMPACT_20",
   145    145   #endif
          146  +
          147  +#if NET_STANDARD_20
          148  +            "NET_STANDARD_20",
          149  +#endif
   146    150   
   147    151   #if PLATFORM_COMPACTFRAMEWORK
   148    152               "PLATFORM_COMPACTFRAMEWORK",
   149    153   #endif
   150    154   
   151    155   #if PRELOAD_NATIVE_LIBRARY
   152    156               "PRELOAD_NATIVE_LIBRARY",

Changes to System.Data.SQLite/SQLiteFunction.cs.

   640    640           }
   641    641       }
   642    642   
   643    643       /// <summary>
   644    644       /// Using reflection, enumerate all assemblies in the current appdomain looking for classes that
   645    645       /// have a SQLiteFunctionAttribute attribute, and registering them accordingly.
   646    646       /// </summary>
   647         -#if !PLATFORM_COMPACTFRAMEWORK
          647  +#if !PLATFORM_COMPACTFRAMEWORK && !NET_STANDARD_20
   648    648       [Security.Permissions.FileIOPermission(Security.Permissions.SecurityAction.Assert, AllFiles = Security.Permissions.FileIOPermissionAccess.PathDiscovery)]
   649    649   #endif
   650    650       static SQLiteFunction()
   651    651       {
   652    652         _registeredFunctions = new Dictionary<SQLiteFunctionAttribute, object>();
   653    653         try
   654    654         {

Added System.Data.SQLite/System.Data.SQLite.NetStandard20.csproj.

            1  +<?xml version="1.0" encoding="utf-8"?>
            2  +<!--
            3  + *
            4  + * System.Data.SQLite.NetStandard20.csproj -
            5  + *
            6  + * Written by Joe Mistachkin.
            7  + * Released to the public domain, use at your own risk!
            8  + *
            9  +-->
           10  +<Project ToolsVersion="15.0">
           11  +  <!--
           12  +  ******************************************************************************
           13  +  **                     Import .NET Core SDK Properties                      **
           14  +  ******************************************************************************
           15  +  -->
           16  +
           17  +  <!--
           18  +      WARNING: This project cannot use the recommended pattern of having the
           19  +               "Project" element simply include the "Sdk" attribute, due to
           20  +               the "BuildDependsOn" property not being honored, see:
           21  +
           22  +               https://github.com/Microsoft/msbuild/issues/1680
           23  +
           24  +               Instead, the .NET Core SDK properties file is imported here
           25  +               and the corresponding targets file is imported right before
           26  +               resetting the "BuildDependsOn" property to include targets
           27  +               necessary for this project.
           28  +  -->
           29  +  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
           30  +
           31  +  <!--
           32  +  ******************************************************************************
           33  +  **                       Project Specific Properties                        **
           34  +  ******************************************************************************
           35  +  -->
           36  +
           37  +  <PropertyGroup>
           38  +    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
           39  +    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
           40  +    <ProjectGuid>{77BE07F7-8183-4A83-8AEC-D46A0C2C026D}</ProjectGuid>
           41  +    <OutputType>Library</OutputType>
           42  +    <AppDesignerFolder>Properties</AppDesignerFolder>
           43  +    <RootNamespace>System.Data.SQLite</RootNamespace>
           44  +    <AssemblyName>System.Data.SQLite</AssemblyName>
           45  +    <SQLiteNetDir>$(MSBuildProjectDirectory)\..</SQLiteNetDir>
           46  +    <NetFx461>true</NetFx461>
           47  +    <IsDotNetStandard>true</IsDotNetStandard>
           48  +    <ConfigurationYear>NetStandard20</ConfigurationYear>
           49  +    <TargetFramework>netstandard2.0</TargetFramework>
           50  +    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
           51  +    <Deterministic>False</Deterministic>
           52  +    <EnableDefaultItems>false</EnableDefaultItems>
           53  +  </PropertyGroup>
           54  +
           55  +  <!--
           56  +  ******************************************************************************
           57  +  **                    .NET Standard 2.0 Specific Targets                    **
           58  +  ******************************************************************************
           59  +  -->
           60  +
           61  +  <Target Name="GenerateResourcesForNetStandard20"
           62  +          Condition="'$(GenerateResourcesForNetStandard20)' != 'false' And
           63  +                     '$(BuildTool)' == 'DotNetCore' And
           64  +                     '$(OperatingSystem)' == 'Windows' And
           65  +                     '$(MSBuildProjectDirectory)' != '' And
           66  +                     !HasTrailingSlash('$(MSBuildProjectDirectory)') And
           67  +                     Exists('$(MSBuildProjectDirectory)\..\Externals\ResGen\ResGen.exe')"
           68  +          Inputs="Resources\SR.resx"
           69  +          Outputs="Generated\SR.resources">
           70  +    <MakeDir Directories="Generated" />
           71  +
           72  +    <Exec Command="&quot;$(MSBuildProjectDirectory)\..\Externals\ResGen\ResGen.exe&quot; Resources\SR.resx Generated\SR.resources &quot;$(MSBuildProjectDirectory)\Resources&quot;" />
           73  +  </Target>
           74  +
           75  +  <!--
           76  +  ******************************************************************************
           77  +  **                     Import Project Default Settings                      **
           78  +  ******************************************************************************
           79  +  -->
           80  +
           81  +  <Import Project="$(SQLiteNetDir)\Targets\SQLite.NET.Platform.Settings.targets" />
           82  +  <Import Project="$(SQLiteNetDir)\Targets\SQLite.NET.Settings.targets" />
           83  +
           84  +  <!--
           85  +  ******************************************************************************
           86  +  **                       Import Project Build Targets                       **
           87  +  ******************************************************************************
           88  +  -->
           89  +
           90  +  <Import Project="$(SQLiteNetDir)\Targets\SQLite.NET.targets" />
           91  +
           92  +  <!--
           93  +  ******************************************************************************
           94  +  **               Convert Project Settings To MSBuild Settings               **
           95  +  ******************************************************************************
           96  +  -->
           97  +
           98  +  <PropertyGroup Condition="'$(BinaryOutputPath)' != ''">
           99  +    <OutputPath>$(BinaryOutputPath)</OutputPath>
          100  +    <DocumentationFile>$(BinaryOutputPath)netstandard2.0\System.Data.SQLite.xml</DocumentationFile>
          101  +  </PropertyGroup>
          102  +
          103  +  <!--
          104  +  ******************************************************************************
          105  +  **                Project Configuration Specific Properties                 **
          106  +  ******************************************************************************
          107  +  -->
          108  +
          109  +  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
          110  +    <DebugSymbols>true</DebugSymbols>
          111  +    <Optimize>false</Optimize>
          112  +    <DefineConstants>DEBUG;TRACE</DefineConstants>
          113  +    <ErrorReport>prompt</ErrorReport>
          114  +  </PropertyGroup>
          115  +
          116  +  <!--
          117  +  ******************************************************************************
          118  +  -->
          119  +
          120  +  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
          121  +    <Optimize>true</Optimize>
          122  +    <DefineConstants>TRACE</DefineConstants>
          123  +    <ErrorReport>prompt</ErrorReport>
          124  +  </PropertyGroup>
          125  +
          126  +  <!--
          127  +  ******************************************************************************
          128  +  **                        Import Assembly References                        **
          129  +  ******************************************************************************
          130  +  -->
          131  +
          132  +  <Import Project="$(MSBuildProjectDirectory)\Targets\System.Data.SQLite.References.targets" />
          133  +
          134  +  <!--
          135  +  ******************************************************************************
          136  +  **       Import Project Compile-Time Options (i.e. Define Constants)        **
          137  +  ******************************************************************************
          138  +  -->
          139  +
          140  +  <Import Project="$(MSBuildProjectDirectory)\Targets\System.Data.SQLite.Properties.targets" />
          141  +
          142  +  <!--
          143  +  ******************************************************************************
          144  +  **                     Import Project Source Code Files                     **
          145  +  ******************************************************************************
          146  +  -->
          147  +
          148  +  <Import Project="$(MSBuildProjectDirectory)\Targets\System.Data.SQLite.Files.targets" />
          149  +
          150  +  <!--
          151  +  ******************************************************************************
          152  +  **                     Project Embedded Resource Files                      **
          153  +  ******************************************************************************
          154  +  -->
          155  +
          156  +  <ItemGroup>
          157  +    <EmbeddedResource Include="Generated\SR.resources">
          158  +      <LogicalName>System.Data.SQLite.SR.resources</LogicalName>
          159  +    </EmbeddedResource>
          160  +  </ItemGroup>
          161  +
          162  +  <!--
          163  +  ******************************************************************************
          164  +  **                       Import .NET Core SDK Targets                       **
          165  +  ******************************************************************************
          166  +  -->
          167  +
          168  +  <!--
          169  +      WARNING: This project cannot use the recommended pattern of having the
          170  +               "Project" element simply include the "Sdk" attribute, see the
          171  +               comment at the top of this file for more information.
          172  +  -->
          173  +  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
          174  +
          175  +  <!--
          176  +  ******************************************************************************
          177  +  **                  Add Targets To BuildDependsOn Property                  **
          178  +  ******************************************************************************
          179  +  -->
          180  +
          181  +  <PropertyGroup>
          182  +    <BuildDependsOn>
          183  +      DetectBuildTool;
          184  +      DetectOperatingSystem;
          185  +      GenerateResourcesForNetStandard20;
          186  +      $(BuildDependsOn);
          187  +      CopyConfigurations;
          188  +    </BuildDependsOn>
          189  +    <CleanDependsOn>
          190  +      $(CleanDependsOn);
          191  +      CleanConfigurations;
          192  +    </CleanDependsOn>
          193  +  </PropertyGroup>
          194  +  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
          195  +       Other similar extension points exist, see Microsoft.Common.targets.
          196  +  <Target Name="BeforeBuild">
          197  +  </Target>
          198  +  <Target Name="AfterBuild">
          199  +  </Target>
          200  +  -->
          201  +</Project>

Changes to System.Data.SQLite/Targets/System.Data.SQLite.Files.targets.

     5      5    * Written by Joe Mistachkin.
     6      6    * Released to the public domain, use at your own risk!
     7      7    *
     8      8   -->
     9      9   <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    10     10     <!--
    11     11     ******************************************************************************
    12         -  **                            Core Files (Common)                           **
           12  +  **                    Project Source Code Files (Common)                    **
    13     13     ******************************************************************************
    14     14     -->
    15     15   
    16     16     <ItemGroup>
    17     17       <Compile Include="AssemblyInfo.cs" />
    18     18       <Compile Include="AssemblySourceIdAttribute.cs" />
    19     19       <Compile Include="AssemblySourceTimeStampAttribute.cs" />
................................................................................
    55     55       <Compile Include="SQLiteTransactionBase.cs" />
    56     56       <Compile Include="UnsafeNativeMethods.cs" />
    57     57       <Compile Include="Resources\SR.Designer.cs">
    58     58         <DependentUpon>SR.resx</DependentUpon>
    59     59         <AutoGen>True</AutoGen>
    60     60         <DesignTime>True</DesignTime>
    61     61       </Compile>
           62  +    <None Include="Configurations\System.Data.SQLite.dll.config" />
           63  +  </ItemGroup>
           64  +
           65  +  <!--
           66  +  ******************************************************************************
           67  +  **                     Project Embedded Resource Files                      **
           68  +  ******************************************************************************
           69  +  -->
           70  +
           71  +  <ItemGroup Condition="'$(IsDotNetStandard)' == 'false'">
    62     72       <EmbeddedResource Include="Resources\SR.resx">
    63     73         <SubType>Designer</SubType>
    64     74         <Generator>ResXFileCodeGenerator</Generator>
    65     75         <LastGenOutput>SR.Designer.cs</LastGenOutput>
    66     76         <LogicalName>System.Data.SQLite.SR.resources</LogicalName>
    67     77       </EmbeddedResource>
    68         -    <None Include="Configurations\System.Data.SQLite.dll.config" />
    69     78     </ItemGroup>
    70     79   
    71     80     <!--
    72     81     ******************************************************************************
    73         -  **                        Core Files (Full Framework)                       **
           82  +  **                Project Source Code Files (Full Framework)                **
    74     83     ******************************************************************************
    75     84     -->
    76     85   
    77     86     <ItemGroup Condition="'$(IsCompactFramework)' == 'false'">
    78     87       <Compile Include="SQLiteEnlistment.cs" />
    79     88       <Compile Condition="'$(NetFx35)' != 'false' Or
    80     89                           '$(NetFx40)' != 'false' Or
................................................................................
   105    114       <EmbeddedResource Include="Resources\SQLiteCommand.bmp" />
   106    115       <EmbeddedResource Include="Resources\SQLiteConnection.bmp" />
   107    116       <EmbeddedResource Include="Resources\SQLiteDataAdapter.bmp" />
   108    117     </ItemGroup>
   109    118   
   110    119     <!--
   111    120     ******************************************************************************
   112         -  **                           Virtual Table Files                            **
          121  +  **                     Virtual Table Source Code Files                      **
   113    122     ******************************************************************************
   114    123     -->
   115    124   
   116    125     <ItemGroup Condition="'$(InteropVirtualTable)' != 'false'">
   117    126       <Compile Include="ISQLiteNativeModule.cs" />
   118    127       <Compile Include="SQLiteModule.cs" />
   119    128       <Compile Include="SQLiteModuleCommon.cs" />
   120    129       <Compile Include="SQLiteModuleEnumerable.cs" />
   121    130       <Compile Include="SQLiteModuleNoop.cs" />
   122    131     </ItemGroup>
   123    132   
   124    133     <!--
   125    134     ******************************************************************************
   126         -  **                         Session Extension Files                          **
          135  +  **                   Session Extension Source Code Files                    **
   127    136     ******************************************************************************
   128    137     -->
   129    138   
   130    139     <ItemGroup Condition="'$(InteropSessionExtension)' != 'false'">
   131    140       <Compile Include="SQLiteSession.cs" />
   132    141     </ItemGroup>
   133    142   </Project>

Changes to System.Data.SQLite/Targets/System.Data.SQLite.Properties.targets.

   142    142               within the project file itself).
   143    143     -->
   144    144     <PropertyGroup Condition="'$(IsCompactFramework)' != 'false' And
   145    145                               '$(TargetFrameworkVersion)' == 'v2.0'">
   146    146       <DefineConstants>$(DefineConstants);NET_COMPACT_20</DefineConstants>
   147    147     </PropertyGroup>
   148    148   
          149  +  <!--
          150  +      NOTE: Only use functionality available in .NET Standard 2.0?  By default,
          151  +            this is disabled.  This must be enabled to successfully build the
          152  +            project using .NET Core 2.0 SDK (if necessary, it will typically
          153  +            be enabled from within the project file itself).
          154  +  -->
          155  +  <PropertyGroup Condition="'$(IsDotNetStandard)' != 'false'">
          156  +    <DefineConstants>$(DefineConstants);NET_STANDARD_20</DefineConstants>
          157  +  </PropertyGroup>
          158  +
   149    159     <!--
   150    160         NOTE: Enable extra internal state checking?
   151    161     -->
   152    162     <PropertyGroup Condition="'$(CheckState)' != 'false'">
   153    163       <DefineConstants>$(DefineConstants);CHECK_STATE</DefineConstants>
   154    164     </PropertyGroup>
   155    165   

Changes to System.Data.SQLite/Targets/System.Data.SQLite.References.targets.

     9      9   <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    10     10     <!--
    11     11     ******************************************************************************
    12     12     **                     Core References (Full Framework)                     **
    13     13     ******************************************************************************
    14     14     -->
    15     15   
    16         -  <ItemGroup Condition="'$(IsCompactFramework)' == 'false'">
           16  +  <ItemGroup Condition="'$(IsCompactFramework)' == 'false' And
           17  +                        '$(IsDotNetStandard)' == 'false'">
    17     18       <Reference Include="System" />
    18     19       <Reference Include="System.Data" />
    19     20       <Reference Include="System.Transactions" />
    20     21       <Reference Include="System.Xml" />
    21     22     </ItemGroup>
    22     23   
    23     24     <!--

Changes to System.Data.SQLite/UnsafeNativeMethods.cs.

   352    352         };
   353    353         #endregion
   354    354   
   355    355         /////////////////////////////////////////////////////////////////////////
   356    356   
   357    357         #region Private Data
   358    358         /// <summary>
   359         -      /// This lock is used to protect the static <see cref="isMono" /> field.
          359  +      /// This lock is used to protect the static <see cref="isMono" /> and
          360  +      /// <see cref="isDotNetCore" /> fields.
   360    361         /// </summary>
   361    362         private static readonly object staticSyncRoot = new object();
   362    363   
   363    364         /////////////////////////////////////////////////////////////////////////
   364    365         /// <summary>
   365    366         /// This type is only present when running on Mono.
   366    367         /// </summary>
   367    368         private static readonly string MonoRuntimeType = "Mono.Runtime";
   368    369   
   369    370         /////////////////////////////////////////////////////////////////////////
   370    371         /// <summary>
          372  +      /// This type is only present when running on .NET Core.
          373  +      /// </summary>
          374  +      private static readonly string DotNetCoreLibType = "System.CoreLib";
          375  +
          376  +      /////////////////////////////////////////////////////////////////////////
          377  +      /// <summary>
   371    378         /// Keeps track of whether we are running on Mono.  Initially null, it is
   372    379         /// set by the <see cref="IsMono" /> method on its first call.  Later, it
   373    380         /// is returned verbatim by the <see cref="IsMono" /> method.
   374    381         /// </summary>
   375    382         private static bool? isMono = null;
          383  +
          384  +      /////////////////////////////////////////////////////////////////////////
          385  +      /// <summary>
          386  +      /// Keeps track of whether we are running on .NET Core.  Initially null,
          387  +      /// it is set by the <see cref="IsDotNetCore" /> method on its first
          388  +      /// call.  Later, it is returned verbatim by the
          389  +      /// <see cref="IsDotNetCore" /> method.
          390  +      /// </summary>
          391  +      private static bool? isDotNetCore = null;
   376    392   
   377    393         /////////////////////////////////////////////////////////////////////////
   378    394         /// <summary>
   379    395         /// Keeps track of whether we successfully invoked the
   380    396         /// <see cref="Debugger.Break" /> method.  Initially null, it is set by
   381    397         /// the <see cref="MaybeBreakIntoDebugger" /> method on its first call.
   382    398         /// </summary>
................................................................................
   417    433                 lock (staticSyncRoot)
   418    434                 {
   419    435                     if (isMono == null)
   420    436                         isMono = (Type.GetType(MonoRuntimeType) != null);
   421    437   
   422    438                     return (bool)isMono;
   423    439                 }
          440  +          }
          441  +          catch
          442  +          {
          443  +              // do nothing.
          444  +          }
          445  +
          446  +          return false;
          447  +      }
          448  +
          449  +      ///////////////////////////////////////////////////////////////////////
          450  +
          451  +      /// <summary>
          452  +      /// Determines whether or not this assembly is running on .NET Core.
          453  +      /// </summary>
          454  +      /// <returns>
          455  +      /// Non-zero if this assembly is running on .NET Core.
          456  +      /// </returns>
          457  +      public static bool IsDotNetCore()
          458  +      {
          459  +          try
          460  +          {
          461  +              lock (staticSyncRoot)
          462  +              {
          463  +                  if (isDotNetCore == null)
          464  +                  {
          465  +                      isDotNetCore = (Type.GetType(
          466  +                          DotNetCoreLibType) != null);
          467  +                  }
          468  +
          469  +                  return (bool)isDotNetCore;
          470  +              }
   424    471             }
   425    472             catch
   426    473             {
   427    474                 // do nothing.
   428    475             }
   429    476   
   430    477             return false;
................................................................................
   849    896         /// </param>
   850    897         /// <returns>
   851    898         /// The native module handle upon success -OR- IntPtr.Zero on failure.
   852    899         /// </returns>
   853    900         private delegate IntPtr LoadLibraryCallback(
   854    901             string fileName
   855    902         );
          903  +
          904  +      /////////////////////////////////////////////////////////////////////////
          905  +
          906  +      /// <summary>
          907  +      /// This delegate is used to wrap the concept of querying the machine
          908  +      /// name of the current process.
          909  +      /// </summary>
          910  +      /// <returns>
          911  +      /// The machine name for the current process -OR- null on failure.
          912  +      /// </returns>
          913  +      private delegate string GetMachineCallback();
   856    914         #endregion
   857    915   
   858    916         /////////////////////////////////////////////////////////////////////////
   859    917   
   860    918         #region Private Methods
   861    919         /// <summary>
   862    920         /// Attempts to load the specified native library file using the Win32
................................................................................
   873    931             )
   874    932         {
   875    933             return UnsafeNativeMethodsWin32.LoadLibrary(fileName);
   876    934         }
   877    935   
   878    936         /////////////////////////////////////////////////////////////////////////
   879    937   
          938  +      /// <summary>
          939  +      /// Attempts to determine the machine name of the current process using
          940  +      /// the Win32 API.
          941  +      /// </summary>
          942  +      /// <returns>
          943  +      /// The machine name for the current process -OR- null on failure.
          944  +      /// </returns>
          945  +      private static string GetMachineWin32()
          946  +      {
          947  +          //
          948  +          // NOTE: When running on Windows, attempt to use the native Win32
          949  +          //       API function (via P/Invoke) that can provide us with the
          950  +          //       processor architecture.
          951  +          //
          952  +          try
          953  +          {
          954  +              UnsafeNativeMethodsWin32.SYSTEM_INFO systemInfo;
          955  +
          956  +              //
          957  +              // NOTE: Query the system information via P/Invoke, thus
          958  +              //       filling the structure.
          959  +              //
          960  +              UnsafeNativeMethodsWin32.GetSystemInfo(out systemInfo);
          961  +
          962  +              //
          963  +              // NOTE: Return the processor architecture value as a string.
          964  +              //
          965  +              return systemInfo.wProcessorArchitecture.ToString();
          966  +          }
          967  +          catch
          968  +          {
          969  +              // do nothing.
          970  +          }
          971  +
          972  +          return null;
          973  +      }
          974  +
          975  +      /////////////////////////////////////////////////////////////////////////
          976  +
   880    977   #if !PLATFORM_COMPACTFRAMEWORK
   881    978         /// <summary>
   882    979         /// Attempts to load the specified native library file using the POSIX
   883    980         /// API.
   884    981         /// </summary>
   885    982         /// <param name="fileName">
   886    983         /// The file name of the native library to load.
................................................................................
   891    988         private static IntPtr LoadLibraryPosix(
   892    989             string fileName
   893    990             )
   894    991         {
   895    992             return UnsafeNativeMethodsPosix.dlopen(
   896    993                 fileName, UnsafeNativeMethodsPosix.RTLD_DEFAULT);
   897    994         }
          995  +
          996  +      /////////////////////////////////////////////////////////////////////////
          997  +
          998  +      /// <summary>
          999  +      /// Attempts to determine the machine name of the current process using
         1000  +      /// the POSIX API.
         1001  +      /// </summary>
         1002  +      /// <returns>
         1003  +      /// The machine name for the current process -OR- null on failure.
         1004  +      /// </returns>
         1005  +      private static string GetMachinePosix()
         1006  +      {
         1007  +          //
         1008  +          // NOTE: When running on POSIX (non-Windows), attempt to query the
         1009  +          //       machine from the operating system via uname().
         1010  +          //
         1011  +          try
         1012  +          {
         1013  +              UnsafeNativeMethodsPosix.utsname utsName = null;
         1014  +
         1015  +              if (UnsafeNativeMethodsPosix.GetOsVersionInfo(ref utsName) &&
         1016  +                  (utsName != null))
         1017  +              {
         1018  +                  return utsName.machine;
         1019  +              }
         1020  +          }
         1021  +          catch
         1022  +          {
         1023  +              // do nothing.
         1024  +          }
         1025  +
         1026  +          return null;
         1027  +      }
   898   1028   #endif
   899   1029         #endregion
   900   1030   
   901   1031         /////////////////////////////////////////////////////////////////////////
   902   1032   
   903   1033         #region Public Methods
   904   1034         /// <summary>
................................................................................
   919   1049   #if !PLATFORM_COMPACTFRAMEWORK
   920   1050             if (!HelperMethods.IsWindows())
   921   1051                 callback = LoadLibraryPosix;
   922   1052   #endif
   923   1053   
   924   1054             return callback(fileName);
   925   1055         }
         1056  +
         1057  +      /////////////////////////////////////////////////////////////////////////
         1058  +
         1059  +      /// <summary>
         1060  +      /// Attempts to determine the machine name of the current process.
         1061  +      /// </summary>
         1062  +      /// <returns>
         1063  +      /// The machine name for the current process -OR- null on failure.
         1064  +      /// </returns>
         1065  +      public static string GetMachine()
         1066  +      {
         1067  +          GetMachineCallback callback = GetMachineWin32;
         1068  +
         1069  +#if !PLATFORM_COMPACTFRAMEWORK
         1070  +          if (!HelperMethods.IsWindows())
         1071  +              callback = GetMachinePosix;
         1072  +#endif
         1073  +
         1074  +          return callback();
         1075  +      }
   926   1076         #endregion
   927   1077     }
   928   1078     #endregion
   929   1079   
   930   1080     /////////////////////////////////////////////////////////////////////////////
   931   1081   
   932   1082     #region Unmanaged Interop Methods Static Class (POSIX)
................................................................................
   933   1083   #if !PLATFORM_COMPACTFRAMEWORK
   934   1084     /// <summary>
   935   1085     /// This class declares P/Invoke methods to call native POSIX APIs.
   936   1086     /// </summary>
   937   1087     [SuppressUnmanagedCodeSecurity]
   938   1088     internal static class UnsafeNativeMethodsPosix
   939   1089     {
         1090  +      /// <summary>
         1091  +      /// This structure is used when running on POSIX operating systems
         1092  +      /// to store information about the current machine, including the
         1093  +      /// human readable name of the operating system as well as that of
         1094  +      /// the underlying hardware.
         1095  +      /// </summary>
         1096  +      internal sealed class utsname
         1097  +      {
         1098  +          public string sysname;  /* Name of this implementation of
         1099  +                                   * the operating system. */
         1100  +          public string nodename; /* Name of this node within the
         1101  +                                   * communications network to which
         1102  +                                   * this node is attached, if any. */
         1103  +          public string release;  /* Current release level of this
         1104  +                                   * implementation. */
         1105  +          public string version;  /* Current version level of this
         1106  +                                   * release. */
         1107  +          public string machine;  /* Name of the hardware type on
         1108  +                                   * which the system is running. */
         1109  +      }
         1110  +
         1111  +      /////////////////////////////////////////////////////////////////////////
         1112  +
         1113  +      /// <summary>
         1114  +      /// This structure is passed directly to the P/Invoke method to
         1115  +      /// obtain the information about the current machine, including
         1116  +      /// the human readable name of the operating system as well as
         1117  +      /// that of the underlying hardware.
         1118  +      /// </summary>
         1119  +      [StructLayout(LayoutKind.Sequential)]
         1120  +      private struct utsname_interop
         1121  +      {
         1122  +          //
         1123  +          // NOTE: The following string fields should be present in
         1124  +          //       this buffer, all of which will be zero-terminated:
         1125  +          //
         1126  +          //                      sysname
         1127  +          //                      nodename
         1128  +          //                      release
         1129  +          //                      version
         1130  +          //                      machine
         1131  +          //
         1132  +          [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4096)]
         1133  +          public byte[] buffer;
         1134  +      }
         1135  +
         1136  +      /////////////////////////////////////////////////////////////////////////
         1137  +
         1138  +      /// <summary>
         1139  +      /// This is the P/Invoke method that wraps the native Unix uname
         1140  +      /// function.  See the POSIX documentation for full details on what it
         1141  +      /// does.
         1142  +      /// </summary>
         1143  +      /// <param name="name">
         1144  +      /// Structure containing a preallocated byte buffer to fill with the
         1145  +      /// requested information.
         1146  +      /// </param>
         1147  +      /// <returns>
         1148  +      /// Zero for success and less than zero upon failure.
         1149  +      /// </returns>
         1150  +#if NET_STANDARD_20
         1151  +      [DllImport("libc",
         1152  +#else
         1153  +      [DllImport("__Internal",
         1154  +#endif
         1155  +          CallingConvention = CallingConvention.Cdecl)]
         1156  +      private static extern int uname(out utsname_interop name);
         1157  +
   940   1158         /////////////////////////////////////////////////////////////////////////
   941   1159         /// <summary>
   942   1160         /// This is the P/Invoke method that wraps the native Unix dlopen
   943   1161         /// function.  See the POSIX documentation for full details on what it
   944   1162         /// does.
   945   1163         /// </summary>
   946   1164         /// <param name="fileName">
................................................................................
   949   1167         /// <param name="mode">
   950   1168         /// This must be a combination of the individual bit flags RTLD_LAZY,
   951   1169         /// RTLD_NOW, RTLD_GLOBAL, and/or RTLD_LOCAL.
   952   1170         /// </param>
   953   1171         /// <returns>
   954   1172         /// The native module handle upon success -OR- IntPtr.Zero on failure.
   955   1173         /// </returns>
   956         -      [DllImport("__Internal", EntryPoint = "dlopen",
         1174  +#if NET_STANDARD_20
         1175  +      [DllImport("libdl",
         1176  +#else
         1177  +      [DllImport("__Internal",
         1178  +#endif
         1179  +          EntryPoint = "dlopen",
   957   1180             CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi,
   958   1181             BestFitMapping = false, ThrowOnUnmappableChar = true,
   959   1182             SetLastError = true)]
   960   1183         internal static extern IntPtr dlopen(string fileName, int mode);
   961   1184   
   962   1185         /////////////////////////////////////////////////////////////////////////
         1186  +      /// <summary>
         1187  +      /// This is the P/Invoke method that wraps the native Unix dlclose
         1188  +      /// function.  See the POSIX documentation for full details on what it
         1189  +      /// does.
         1190  +      /// </summary>
         1191  +      /// <param name="module">
         1192  +      /// The handle to the loaded native library.
         1193  +      /// </param>
         1194  +      /// <returns>
         1195  +      /// Zero upon success -OR- non-zero on failure.
         1196  +      /// </returns>
         1197  +#if NET_STANDARD_20
         1198  +      [DllImport("libdl",
         1199  +#else
         1200  +      [DllImport("__Internal",
         1201  +#endif
         1202  +          EntryPoint = "dlclose",
         1203  +          CallingConvention = CallingConvention.Cdecl, SetLastError = true)]
         1204  +      internal static extern int dlclose(IntPtr module);
         1205  +
         1206  +      /////////////////////////////////////////////////////////////////////////
         1207  +
         1208  +      #region Private Constants
   963   1209         /// <summary>
   964   1210         /// For use with dlopen(), bind function calls lazily.
   965   1211         /// </summary>
   966   1212         internal const int RTLD_LAZY = 0x1;
   967   1213   
   968   1214         /////////////////////////////////////////////////////////////////////////
   969   1215         /// <summary>
................................................................................
   983   1229         /// </summary>
   984   1230         internal const int RTLD_LOCAL = 0x000;
   985   1231   
   986   1232         /////////////////////////////////////////////////////////////////////////
   987   1233         /// <summary>
   988   1234         /// For use with dlopen(), the defaults used by this class.
   989   1235         /// </summary>
   990         -      internal  const int RTLD_DEFAULT = RTLD_NOW | RTLD_GLOBAL;
         1236  +      internal const int RTLD_DEFAULT = RTLD_NOW | RTLD_GLOBAL;
         1237  +      #endregion
         1238  +
         1239  +      /////////////////////////////////////////////////////////////////////////
         1240  +
         1241  +      #region Private Data
         1242  +      /// <summary>
         1243  +      /// These are the characters used to separate the string fields within
         1244  +      /// the raw buffer returned by the <see cref="uname" /> P/Invoke method.
         1245  +      /// </summary>
         1246  +      private static readonly char[] utsNameSeparators = { '\0' };
         1247  +      #endregion
         1248  +
         1249  +      /////////////////////////////////////////////////////////////////////////
         1250  +
         1251  +      #region Private Methods
         1252  +      /// <summary>
         1253  +      /// This method is a wrapper around the <see cref="uname" /> P/Invoke
         1254  +      /// method that extracts and returns the human readable strings from
         1255  +      /// the raw buffer.
         1256  +      /// </summary>
         1257  +      /// <param name="utsName">
         1258  +      /// This structure, which contains strings, will be filled based on the
         1259  +      /// data placed in the raw buffer returned by the <see cref="uname" />
         1260  +      /// P/Invoke method.
         1261  +      /// </param>
         1262  +      /// <returns>
         1263  +      /// Non-zero upon success; otherwise, zero.
         1264  +      /// </returns>
         1265  +      internal static bool GetOsVersionInfo(
         1266  +          ref utsname utsName
         1267  +          )
         1268  +      {
         1269  +          try
         1270  +          {
         1271  +              utsname_interop utfNameInterop;
         1272  +
         1273  +              if (uname(out utfNameInterop) < 0)
         1274  +                  return false;
         1275  +
         1276  +              if (utfNameInterop.buffer == null)
         1277  +                  return false;
         1278  +
         1279  +              string bufferAsString = Encoding.UTF8.GetString(
         1280  +                  utfNameInterop.buffer);
         1281  +
         1282  +              if ((bufferAsString == null) || (utsNameSeparators == null))
         1283  +                  return false;
         1284  +
         1285  +              bufferAsString = bufferAsString.Trim(utsNameSeparators);
         1286  +
         1287  +              string[] parts = bufferAsString.Split(
         1288  +                  utsNameSeparators, StringSplitOptions.RemoveEmptyEntries);
         1289  +
         1290  +              if (parts == null)
         1291  +                  return false;
         1292  +
         1293  +              utsname localUtsName = new utsname();
         1294  +
         1295  +              if (parts.Length >= 1)
         1296  +                  localUtsName.sysname = parts[0];
         1297  +
         1298  +              if (parts.Length >= 2)
         1299  +                  localUtsName.nodename = parts[1];
         1300  +
         1301  +              if (parts.Length >= 3)
         1302  +                  localUtsName.release = parts[2];
         1303  +
         1304  +              if (parts.Length >= 4)
         1305  +                  localUtsName.version = parts[3];
         1306  +
         1307  +              if (parts.Length >= 5)
         1308  +                  localUtsName.machine = parts[4];
         1309  +
         1310  +              utsName = localUtsName;
         1311  +              return true;
         1312  +          }
         1313  +          catch
         1314  +          {
         1315  +              // do nothing.
         1316  +          }
         1317  +
         1318  +          return false;
         1319  +      }
         1320  +      #endregion
   991   1321     }
   992   1322   #endif
   993   1323     #endregion
   994   1324   
   995   1325     /////////////////////////////////////////////////////////////////////////////
   996   1326   
   997   1327     #region Unmanaged Interop Methods Static Class (Win32)
................................................................................
  1016   1346         /// The native module handle upon success -OR- IntPtr.Zero on failure.
  1017   1347         /// </returns>
  1018   1348   #if !PLATFORM_COMPACTFRAMEWORK
  1019   1349         [DllImport("kernel32",
  1020   1350   #else
  1021   1351         [DllImport("coredll",
  1022   1352   #endif
  1023         - CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto,
         1353  +          CallingConvention = CallingConvention.Winapi, CharSet = CharSet.Auto,
  1024   1354   #if !PLATFORM_COMPACTFRAMEWORK
  1025   1355             BestFitMapping = false, ThrowOnUnmappableChar = true,
  1026   1356   #endif
  1027   1357             SetLastError = true)]
  1028   1358         internal static extern IntPtr LoadLibrary(string fileName);
  1029   1359   
  1030   1360         /////////////////////////////////////////////////////////////////////////
  1031   1361   
  1032         -#if PLATFORM_COMPACTFRAMEWORK
  1033   1362         /// <summary>
  1034   1363         /// This is the P/Invoke method that wraps the native Win32 GetSystemInfo
  1035   1364         /// function.  See the MSDN documentation for full details on what it
  1036   1365         /// does.
  1037   1366         /// </summary>
  1038   1367         /// <param name="systemInfo">
  1039   1368         /// The system information structure to be filled in by the function.
  1040   1369         /// </param>
  1041         -      [DllImport("coredll", CallingConvention = CallingConvention.Winapi)]
         1370  +#if !PLATFORM_COMPACTFRAMEWORK
         1371  +      [DllImport("kernel32",
         1372  +#else
         1373  +      [DllImport("coredll",
         1374  +#endif
         1375  +          CallingConvention = CallingConvention.Winapi)]
  1042   1376         internal static extern void GetSystemInfo(out SYSTEM_INFO systemInfo);
  1043   1377   
  1044   1378         /////////////////////////////////////////////////////////////////////////
  1045   1379         /// <summary>
  1046   1380         /// This enumeration contains the possible values for the processor
  1047   1381         /// architecture field of the system information structure.
  1048   1382         /// </summary>
................................................................................
  1071   1405         internal struct SYSTEM_INFO
  1072   1406         {
  1073   1407             public ProcessorArchitecture wProcessorArchitecture;
  1074   1408             public ushort wReserved; /* NOT USED */
  1075   1409             public uint dwPageSize; /* NOT USED */
  1076   1410             public IntPtr lpMinimumApplicationAddress; /* NOT USED */
  1077   1411             public IntPtr lpMaximumApplicationAddress; /* NOT USED */
         1412  +#if PLATFORM_COMPACTFRAMEWORK
  1078   1413             public uint dwActiveProcessorMask; /* NOT USED */
         1414  +#else
         1415  +          public IntPtr dwActiveProcessorMask; /* NOT USED */
         1416  +#endif
  1079   1417             public uint dwNumberOfProcessors; /* NOT USED */
  1080   1418             public uint dwProcessorType; /* NOT USED */
  1081   1419             public uint dwAllocationGranularity; /* NOT USED */
  1082   1420             public ushort wProcessorLevel; /* NOT USED */
  1083   1421             public ushort wProcessorRevision; /* NOT USED */
  1084   1422         }
  1085         -#endif
  1086   1423     }
  1087   1424     #endregion
  1088   1425   
  1089   1426     /////////////////////////////////////////////////////////////////////////////
  1090   1427   
  1091   1428     #region Unmanaged Interop Methods Static Class (SQLite)
  1092   1429     /// <summary>
................................................................................
  1279   1616                             StringComparer.OrdinalIgnoreCase);
  1280   1617   
  1281   1618                     //
  1282   1619                     // NOTE: Setup the list of platform names associated with
  1283   1620                     //       the supported processor architectures.
  1284   1621                     //
  1285   1622                     processorArchitecturePlatforms.Add("x86", "Win32");
         1623  +                  processorArchitecturePlatforms.Add("x86_64", "x64");
  1286   1624                     processorArchitecturePlatforms.Add("AMD64", "x64");
  1287   1625                     processorArchitecturePlatforms.Add("IA64", "Itanium");
  1288   1626                     processorArchitecturePlatforms.Add("ARM", "WinCE");
  1289   1627                 }
  1290   1628   
  1291   1629   #if SQLITE_STANDARD || USE_INTEROP_DLL || PLATFORM_COMPACTFRAMEWORK
  1292   1630   #if PRELOAD_NATIVE_LIBRARY
................................................................................
  1293   1631                 //
  1294   1632                 // BUGBUG: What about other application domains?
  1295   1633                 //
  1296   1634                 if (_SQLiteNativeModuleHandle == IntPtr.Zero)
  1297   1635                 {
  1298   1636                     string baseDirectory = null;
  1299   1637                     string processorArchitecture = null;
         1638  +                  bool allowBaseDirectoryOnly = false;
  1300   1639   
  1301   1640                     /* IGNORED */
  1302   1641                     SearchForDirectory(
  1303         -                      ref baseDirectory, ref processorArchitecture);
         1642  +                      ref baseDirectory, ref processorArchitecture,
         1643  +                      ref allowBaseDirectoryOnly);
  1304   1644   
  1305   1645                     //
  1306   1646                     // NOTE: Attempt to pre-load the SQLite core library (or
  1307   1647                     //       interop assembly) and store both the file name
  1308   1648                     //       and native module handle for later usage.
  1309   1649                     //
  1310   1650                     /* IGNORED */
  1311         -                  PreLoadSQLiteDll(
  1312         -                      baseDirectory, processorArchitecture,
         1651  +                  PreLoadSQLiteDll(baseDirectory,
         1652  +                      processorArchitecture, allowBaseDirectoryOnly,
  1313   1653                         ref _SQLiteNativeModuleFileName,
  1314   1654                         ref _SQLiteNativeModuleHandle);
  1315   1655                 }
  1316   1656   #endif
  1317   1657   #endif
  1318   1658             }
  1319   1659         }
................................................................................
  2344   2684         /// Upon success, this parameter will be modified to refer to the base
  2345   2685         /// directory containing the native SQLite library.
  2346   2686         /// </param>
  2347   2687         /// <param name="processorArchitecture">
  2348   2688         /// Upon success, this parameter will be modified to refer to the name
  2349   2689         /// of the immediate directory (i.e. the offset from the base directory)
  2350   2690         /// containing the native SQLite library.
         2691  +      /// </param>
         2692  +      /// <param name="allowBaseDirectoryOnly">
         2693  +      /// Upon success, this parameter will be modified to non-zero only if
         2694  +      /// the base directory itself should be allowed for loading the native
         2695  +      /// library.
  2351   2696         /// </param>
  2352   2697         /// <returns>
  2353   2698         /// Non-zero (success) if the native SQLite library was found; otherwise,
  2354   2699         /// zero (failure).
  2355   2700         /// </returns>
  2356   2701         private static bool SearchForDirectory(
  2357         -          ref string baseDirectory,        /* out */
  2358         -          ref string processorArchitecture /* out */
         2702  +          ref string baseDirectory,         /* out */
         2703  +          ref string processorArchitecture, /* out */
         2704  +          ref bool allowBaseDirectoryOnly   /* out */
  2359   2705             )
  2360   2706         {
  2361   2707             if (GetSettingValue(
  2362   2708                   "PreLoadSQLite_NoSearchForDirectory", null) != null)
  2363   2709             {
  2364   2710                 return false; /* DISABLED */
  2365   2711             }
................................................................................
  2381   2727             //
  2382   2728             string[] directories = {
  2383   2729                 GetAssemblyDirectory(),
  2384   2730   #if !PLATFORM_COMPACTFRAMEWORK
  2385   2731                 AppDomain.CurrentDomain.BaseDirectory,
  2386   2732   #endif
  2387   2733             };
         2734  +
         2735  +          string extraSubDirectory = null;
         2736  +
         2737  +          if ((GetSettingValue(
         2738  +                  "PreLoadSQLite_AllowBaseDirectoryOnly", null) != null) ||
         2739  +              (HelperMethods.IsDotNetCore() && !HelperMethods.IsWindows()))
         2740  +          {
         2741  +              extraSubDirectory = String.Empty; /* .NET Core on POSIX */
         2742  +          }
  2388   2743   
  2389   2744             string[] subDirectories = {
  2390         -              GetProcessorArchitecture(), GetPlatformName(null)
         2745  +              GetProcessorArchitecture(), /* e.g. "x86" */
         2746  +              GetPlatformName(null),      /* e.g. "Win32" */
         2747  +              extraSubDirectory           /* base directory only? */
  2391   2748             };
  2392   2749   
  2393   2750             foreach (string directory in directories)
  2394   2751             {
  2395   2752                 if (directory == null)
  2396   2753                     continue;
  2397   2754   
................................................................................
  2426   2783                         {
  2427   2784                             // do nothing.
  2428   2785                         }
  2429   2786   #endif
  2430   2787   
  2431   2788                         baseDirectory = directory;
  2432   2789                         processorArchitecture = subDirectory;
         2790  +                      allowBaseDirectoryOnly = (subDirectory.Length == 0);
         2791  +
  2433   2792                         return true; /* FOUND */
  2434   2793                     }
  2435   2794                 }
  2436   2795             }
  2437   2796   
  2438   2797             return false; /* NOT FOUND */
  2439   2798         }
................................................................................
  2597   2956                 }
  2598   2957                 catch
  2599   2958                 {
  2600   2959                     // do nothing.
  2601   2960                 }
  2602   2961   #endif
  2603   2962             }
  2604         -#else
         2963  +#endif
         2964  +
         2965  +          /////////////////////////////////////////////////////////////////////
         2966  +
  2605   2967             if (processorArchitecture == null)
  2606   2968             {
  2607   2969                 //
  2608         -              // NOTE: On the .NET Compact Framework, attempt to use the native
  2609         -              //       Win32 API function (via P/Invoke) that can provide us
  2610         -              //       with the processor architecture.
  2611         -              //
  2612         -              try
  2613         -              {
  2614         -                  //
  2615         -                  // NOTE: The output of the GetSystemInfo function will be
  2616         -                  //       placed here.  Only the processor architecture field
  2617         -                  //       is used by this method.
  2618         -                  //
  2619         -                  UnsafeNativeMethodsWin32.SYSTEM_INFO systemInfo;
  2620         -
  2621         -                  //
  2622         -                  // NOTE: Query the system information via P/Invoke, thus
  2623         -                  //       filling the structure.
  2624         -                  //
  2625         -                  UnsafeNativeMethodsWin32.GetSystemInfo(out systemInfo);
  2626         -
  2627         -                  //
  2628         -                  // NOTE: Return the processor architecture value as a string.
  2629         -                  //
  2630         -                  processorArchitecture =
  2631         -                      systemInfo.wProcessorArchitecture.ToString();
  2632         -              }
  2633         -              catch
  2634         -              {
  2635         -                  // do nothing.
  2636         -              }
  2637         -
  2638         -              //
  2639         -              // NOTE: Upon failure, return an empty string.  This will prevent
  2640         -              //       the calling method from considering this method call a
  2641         -              //       "failure".
  2642         -              //
  2643         -              processorArchitecture = String.Empty;
  2644         -          }
  2645         -#endif
         2970  +              // NOTE: Default to the processor architecture reported by the
         2971  +              //       appropriate native operating system API, if any.
         2972  +              //
         2973  +              processorArchitecture = NativeLibraryHelper.GetMachine();
         2974  +
         2975  +              //
         2976  +              // NOTE: Upon failure, return empty string.  This will prevent
         2977  +              //       the calling method from considering this method call
         2978  +              //       a "failure".
         2979  +              //
         2980  +              if (processorArchitecture == null)
         2981  +                  processorArchitecture = String.Empty;
         2982  +          }
  2646   2983   
  2647   2984             /////////////////////////////////////////////////////////////////////
  2648   2985   
  2649   2986             return processorArchitecture;
  2650   2987         }
  2651   2988   
  2652   2989         /////////////////////////////////////////////////////////////////////////
................................................................................
  2697   3034         /// the current application domain).  This directory should contain the
  2698   3035         /// processor architecture specific sub-directories.
  2699   3036         /// </param>
  2700   3037         /// <param name="processorArchitecture">
  2701   3038         /// The requested processor architecture, null for default (the
  2702   3039         /// processor architecture of the current process).  This caller should
  2703   3040         /// almost always specify null for this parameter.
         3041  +      /// </param>
         3042  +      /// <param name="allowBaseDirectoryOnly">
         3043  +      /// Non-zero indicates that the native SQLite library can be loaded
         3044  +      /// from the base directory itself.
  2704   3045         /// </param>
  2705   3046         /// <param name="nativeModuleFileName">
  2706   3047         /// The candidate native module file name to load will be stored here,
  2707   3048         /// if necessary.
  2708   3049         /// </param>
  2709   3050         /// <param name="nativeModuleHandle">
  2710   3051         /// The native module handle as returned by LoadLibrary will be stored
................................................................................
  2714   3055         /// <returns>
  2715   3056         /// Non-zero if the native module was loaded successfully; otherwise,
  2716   3057         /// zero.
  2717   3058         /// </returns>
  2718   3059         private static bool PreLoadSQLiteDll(
  2719   3060             string baseDirectory,            /* in */
  2720   3061             string processorArchitecture,    /* in */
         3062  +          bool allowBaseDirectoryOnly,     /* in */
  2721   3063             ref string nativeModuleFileName, /* out */
  2722   3064             ref IntPtr nativeModuleHandle    /* out */
  2723   3065             )
  2724   3066         {
  2725   3067             //
  2726   3068             // NOTE: If the specified base directory is null, use the default
  2727   3069             //       (i.e. attempt to automatically detect it).
................................................................................
  2742   3084             string fileNameOnly = GetNativeLibraryFileNameOnly();
  2743   3085   
  2744   3086             if (fileNameOnly == null)
  2745   3087                 return false;
  2746   3088   
  2747   3089             //
  2748   3090             // NOTE: If the native SQLite library exists in the base directory
  2749         -          //       itself, stop now.
         3091  +          //       itself, possibly stop now.
  2750   3092             //
  2751   3093             string fileName = FixUpDllFileName(MaybeCombinePath(baseDirectory,
  2752   3094                 fileNameOnly));
  2753   3095   
  2754   3096             if (File.Exists(fileName))
  2755         -              return false;
         3097  +          {
         3098  +              //
         3099  +              // NOTE: If the caller is allowing the base directory itself
         3100  +              //       to be used, also make sure a processor architecture
         3101  +              //       was not specified; if either condition is false just
         3102  +              //       stop now and return failure.
         3103  +              //
         3104  +              if (allowBaseDirectoryOnly &&
         3105  +                  String.IsNullOrEmpty(processorArchitecture))
         3106  +              {
         3107  +                  goto baseDirOnly;
         3108  +              }
         3109  +              else
         3110  +              {
         3111  +                  return false;
         3112  +              }
         3113  +          }
  2756   3114   
  2757   3115             //
  2758   3116             // NOTE: If the specified processor architecture is null, use the
  2759   3117             //       default.
  2760   3118             //
  2761   3119             if (processorArchitecture == null)
  2762   3120                 processorArchitecture = GetProcessorArchitecture();
................................................................................
  2801   3159   
  2802   3160                 //
  2803   3161                 // NOTE: If the file does not exist, skip trying to load it.
  2804   3162                 //
  2805   3163                 if (!File.Exists(fileName))
  2806   3164                     return false;
  2807   3165             }
         3166  +
         3167  +      baseDirOnly:
  2808   3168   
  2809   3169             try
  2810   3170             {
  2811   3171   #if !NET_COMPACT_20 && TRACE_PRELOAD
  2812   3172                 try
  2813   3173                 {
  2814   3174                     //

Added Targets/SQLite.NET.NetStandard20.Settings.targets.

            1  +<!--
            2  + *
            3  + * SQLite.NET.NetStandard20.Settings.targets -
            4  + *
            5  + * Written by Joe Mistachkin.
            6  + * Released to the public domain, use at your own risk!
            7  + *
            8  +-->
            9  +<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
           10  +  <!--
           11  +  ******************************************************************************
           12  +  **               .NET Standard 2.0 Specific Settings (Common)               **
           13  +  ******************************************************************************
           14  +  -->
           15  +
           16  +  <PropertyGroup>
           17  +    <!--
           18  +        TODO: This list of properties must be kept synchronized with the common
           19  +              list in the "build_net_standard_20.bat" file.
           20  +    -->
           21  +    <ConfigurationSuffix Condition="'$(ConfigurationSuffix)' == ''">NetStandard20</ConfigurationSuffix>
           22  +    <InteropCodec Condition="'$(InteropCodec)' == ''">false</InteropCodec>
           23  +    <InteropLog Condition="'$(InteropLog)' == ''">false</InteropLog>
           24  +  </PropertyGroup>
           25  +
           26  +  <!--
           27  +  ******************************************************************************
           28  +  **               .NET Standard 2.0 Specific Settings (Debug)                **
           29  +  ******************************************************************************
           30  +  -->
           31  +
           32  +  <PropertyGroup Condition="'$(Configuration)' == 'Debug'">
           33  +    <!--
           34  +        TODO: This list of properties must be kept synchronized with the debug
           35  +              list in the "build_net_standard_20.bat" file.
           36  +    -->
           37  +    <CheckState Condition="'$(CheckState)' == ''">true</CheckState>
           38  +    <CountHandle Condition="'$(CountHandle)' == ''">true</CountHandle>
           39  +    <TraceConnection Condition="'$(TraceConnection)' == ''">true</TraceConnection>
           40  +    <TraceDetection Condition="'$(TraceDetection)' == ''">true</TraceDetection>
           41  +    <TraceHandle Condition="'$(TraceHandle)' == ''">true</TraceHandle>
           42  +    <TraceStatement Condition="'$(TraceStatement)' == ''">true</TraceStatement>
           43  +    <TrackMemoryBytes Condition="'$(TrackMemoryBytes)' == ''">true</TrackMemoryBytes>
           44  +  </PropertyGroup>
           45  +</Project>

Changes to Targets/SQLite.NET.Settings.targets.

   415    415       <UseSqliteStandard Condition="'$(UseSqliteStandard)' == ''">false</UseSqliteStandard>
   416    416   
   417    417       <!--
   418    418           NOTE: Is the project being built to support the .NET Compact Framework?
   419    419       -->
   420    420       <IsCompactFramework Condition="'$(IsCompactFramework)' == ''">false</IsCompactFramework>
   421    421   
          422  +    <!--
          423  +        NOTE: Is the project being built to support .NET Standard 2.0?
          424  +    -->
          425  +    <IsDotNetStandard Condition="'$(IsDotNetStandard)' == ''">false</IsDotNetStandard>
          426  +
   422    427       <!--
   423    428           NOTE: Emit an AssemblyFlags attribute that includes the Retargetable
   424    429                 flag from the AssemblyNameFlags enumeration?
   425    430       -->
   426    431       <IsRetargetable Condition="'$(IsRetargetable)' == ''">false</IsRetargetable>
   427    432   
   428    433       <!--
................................................................................
   858    863   
   859    864     <!--
   860    865     ******************************************************************************
   861    866     **                         Relative Path Properties                         **
   862    867     ******************************************************************************
   863    868     -->
   864    869   
   865         -  <PropertyGroup Condition="'$(SQLiteNetDir)' != ''">
          870  +  <PropertyGroup Condition="'$(SQLiteNetDir)' != '' And '$(IsDotNetStandard)' == 'false'">
   866    871       <!--
   867    872           NOTE: Keep all the intermediate files in one place.  The Visual Studio
   868    873                 IDE seems to have a nasty habit of ignoring this setting.  The
   869    874                 Visual Studio IDE then fails to build the project(s) properly when
   870    875                 the output does not end up where it expects the output to be.  The
   871    876                 value of this property must have a trailing backslash.
   872    877       -->

Changes to Targets/SQLite.NET.targets.

   255    255                        '$(Platform)' != ''">
   256    256       <Exec Command="XCOPY &quot;$(OutDir)$(TargetName).*&quot; &quot;$(OutDir)..\..\$(BaseConfiguration)\bin\$(Platform)\&quot; /D /E /V /I /F /H /Y" />
   257    257   
   258    258       <Exec Condition="'$(DoesMachineMatchPlatform)' != 'false'"
   259    259             Command="XCOPY &quot;$(OutDir)$(TargetName).*&quot; &quot;$(OutDir)..\..\$(BaseConfiguration)\bin\&quot; /D /E /V /I /F /H /Y" />
   260    260     </Target>
   261    261   
          262  +  <!--
          263  +  ******************************************************************************
          264  +  -->
          265  +
          266  +  <Target Name="DetectBuildTool"
          267  +          Condition="'$(DetectBuildTool)' != 'false' And
          268  +                     '$(MSBuildBinPath)' != '' And
          269  +                     !HasTrailingSlash('$(MSBuildBinPath)')">
          270  +    <CreateProperty Condition="Exists('$(MSBuildBinPath)\MSBuild.exe')"
          271  +                    Value="MSBuild">
          272  +      <Output TaskParameter="Value" PropertyName="BuildTool" />
          273  +    </CreateProperty>
          274  +
          275  +    <CreateProperty Condition="Exists('$(MSBuildBinPath)\xbuild.exe')"
          276  +                    Value="XBuild">
          277  +      <Output TaskParameter="Value" PropertyName="BuildTool" />
          278  +    </CreateProperty>
          279  +
          280  +    <CreateProperty Condition="Exists('$(MSBuildBinPath)\MSBuild.dll')"
          281  +                    Value="DotNetCore">
          282  +      <Output TaskParameter="Value" PropertyName="BuildTool" />
          283  +    </CreateProperty>
          284  +
          285  +    <CreateProperty Condition="!Exists('$(MSBuildBinPath)\MSBuild.exe') And
          286  +                               !Exists('$(MSBuildBinPath)\xbuild.exe') And
          287  +                               !Exists('$(MSBuildBinPath)\MSBuild.dll')"
          288  +                    Value="Unknown">
          289  +      <Output TaskParameter="Value" PropertyName="BuildTool" />
          290  +    </CreateProperty>
          291  +  </Target>
          292  +
          293  +  <!--
          294  +  ******************************************************************************
          295  +  -->
          296  +
          297  +  <Target Name="DetectOperatingSystem"
          298  +          Condition="'$(DetectOperatingSystem)' != 'false'">
          299  +    <CreateProperty Condition="'$(OS)' == 'Windows_NT'" Value="Windows">
          300  +      <Output TaskParameter="Value" PropertyName="OperatingSystem" />
          301  +    </CreateProperty>
          302  +
          303  +    <CreateProperty Condition="'$(OS)' == 'Unix'" Value="Unix">
          304  +      <Output TaskParameter="Value" PropertyName="OperatingSystem" />
          305  +    </CreateProperty>
          306  +
          307  +    <CreateProperty Condition="'$(OS)' == 'OSX'" Value="MacOSX">
          308  +      <Output TaskParameter="Value" PropertyName="OperatingSystem" />
          309  +    </CreateProperty>
          310  +
          311  +    <CreateProperty Condition="'$(OS)' != 'Windows_NT' And
          312  +                               '$(OS)' != 'Unix' And
          313  +                               '$(OS)' != 'OSX'"
          314  +                    Value="Unknown">
          315  +      <Output TaskParameter="Value" PropertyName="OperatingSystem" />
          316  +    </CreateProperty>
          317  +  </Target>
          318  +
   262    319     <!--
   263    320     ******************************************************************************
   264    321     **                        Visual Studio 2017 Targets                        **
   265    322     ******************************************************************************
   266    323     -->
   267    324   
   268    325     <Target Name="MaybeFindVsSdk2017"

Changes to Tests/basic.eagle.

  1808   1808             {[llength [file list $::directory(temp) etilqs_*]] > 0}]
  1809   1809   
  1810   1810         if {$::found(temp)} then {
  1811   1811           return
  1812   1812         }
  1813   1813       }
  1814   1814     }
  1815         -
  1816         -  object import System.Threading
  1817   1815   } -body {
  1818   1816     set result [list]
  1819   1817   
  1820   1818     #
  1821   1819     # NOTE: Attempt to modify the process-wide data and temporary directory
  1822   1820     #       settings for the SQLite core library.
  1823   1821     #
................................................................................
  1837   1835       sql execute $db "INSERT INTO t1 (x) VALUES(?);" \
  1838   1836           [list param1 String [expr {randstr(1024)}]]
  1839   1837     }
  1840   1838   
  1841   1839     set found(data) [expr \
  1842   1840         {[llength [file list $directory(data) $fileName]] == 1}]
  1843   1841   
  1844         -  set t [object create -alias Thread threadStart]
  1845         -  sql execute $db "BEGIN TRANSACTION;"; $t Start
         1842  +  set t [createThread threadStart]
         1843  +  sql execute $db "BEGIN TRANSACTION;"; startThread $t
  1846   1844   
  1847   1845     for {set i 1} {$i < 1000} {incr i} {
  1848   1846       #
  1849   1847       # NOTE: Execute a query that should force the creation of a temporary file
  1850   1848       #       for its statement journal.
  1851   1849       #
  1852   1850       sql execute $db "UPDATE t1 SET x = ?;" \
................................................................................
  1900   1898   
  1901   1899     if {[info exists directory(temp)] && \
  1902   1900         [file exists $directory(temp)] && \
  1903   1901         [file isdirectory $directory(temp)]} then {
  1904   1902       file delete -recursive -force $directory(temp)
  1905   1903     }
  1906   1904   
  1907         -  object unimport -importpattern System.Threading
  1908         -
  1909   1905     if {[info exists t] && [cleanupThread $t]} then {
  1910   1906       unset t
  1911   1907     }
  1912   1908   
  1913   1909     catch {object removecallback threadStart}
  1914   1910   
  1915   1911     unset -nocomplain t found i db fileName result directory
................................................................................
  3840   3836     rename myFuncFinalCallback ""
  3841   3837     rename myFuncStepCallback ""
  3842   3838     rename myFuncInvokeCallback ""
  3843   3839     rename myFuncCallback ""
  3844   3840     rename hashManagedArray ""
  3845   3841     rename getHashCode ""
  3846   3842     rename getMyFuncArgs ""
  3847         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
  3848         -System.Data.SQLite} -match regexp -result {^0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 \{1\
  3849         -2 3 A a M m Z z\} True 1 True 1 True 1 True 1 True 1 True 1 True 1 True 1\
  3850         -\{(?:-)?\d+ (?:-)?\d+\}$}}
         3843  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
         3844  +compile.EMIT SQLite System.Data.SQLite} -match regexp -result {^0 -1 0 -1 0 -1\
         3845  +0 -1 0 -1 0 -1 0 \{1 2 3 A a M m Z z\} True 1 True 1 True 1 True 1 True 1 True\
         3846  +1 True 1 True 1 \{(?:-)?\d+ (?:-)?\d+\}$}}
  3851   3847   
  3852   3848   ###############################################################################
  3853   3849   
  3854   3850   runTest {test data-1.75 {SQLiteCommand.Reset method} -setup {
  3855   3851     setupDb [set fileName data-1.75.db]
  3856   3852   } -body {
  3857   3853     set connection [getDbConnection]

Changes to Tests/memory.eagle.

    42     42   #
    43     43   checkForSQLiteDirectories $test_channel
    44     44   getSQLiteHandleCounts $test_channel
    45     45   reportSQLiteResources $test_channel
    46     46   
    47     47   ###############################################################################
    48     48   
           49  +#
           50  +# NOTE: This test is disabled for .NET Core due to its lack of support for
           51  +#       performance counters.
           52  +#
    49     53   runTest {test memory-1.1 {SQLiteDataReader memory testing} -setup {
    50     54     setupMemoryCounters counter
    51     55     reportMemoryCounters $test_channel counter initial
    52     56   
    53     57     setupDb [set fileName $test_repository_file] \
    54     58         "" "" "" "" "Read Only=True" false false
    55     59   } -body {
................................................................................
   121    125     freeDbConnection
   122    126   
   123    127     unset -nocomplain dataReader connection
   124    128   
   125    129     cleanupDb $fileName db true false false
   126    130   
   127    131     unset -nocomplain working sql counter db fileName
   128         -} -constraints \
   129         -{eagle command.object windows monoBug28 command.sql compile.DATA SQLite\
   130         -System.Data.SQLite fossil_repository_file variable_test_repository_file} \
   131         --result {}}
          132  +} -constraints [fixConstraints {eagle command.object !dotNetCore windows\
          133  +monoBug28 command.sql compile.DATA SQLite System.Data.SQLite\
          134  +fossil_repository_file variable_test_repository_file}] -result {}}
   132    135   
   133    136   ###############################################################################
   134    137   
   135    138   #
   136    139   # NOTE: Report after test.
   137    140   #
   138    141   checkForSQLiteDirectories $test_channel

Changes to Tests/session.eagle.

   858    858     catch {
   859    859       foreach callbackResult $callbackResults {
   860    860         catch {object dispose $callbackResult}
   861    861       }
   862    862     }
   863    863   
   864    864     unset -nocomplain callbackResult callbackResults db fileName
   865         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
   866         -System.Data.SQLite SQLiteInterop\
          865  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
          866  +compile.EMIT SQLite System.Data.SQLite SQLiteInterop\
   867    867   defineConstant.System.Data.SQLite.INTEROP_SESSION_EXTENSION} -result {IsEmpty\
   868    868   True MatchT2 false IsEmpty False MatchT1 true IsEmpty False MatchT2 true\
   869    869   IsEmpty False MatchT1 true}}
   870    870   
   871    871   ###############################################################################
   872    872   
   873    873   runTest {test session-1.6.1 {combine/apply change sets (memory)} -setup {
................................................................................
   924    924     catch {
   925    925       foreach callbackResult $callbackResults {
   926    926         catch {object dispose $callbackResult}
   927    927       }
   928    928     }
   929    929   
   930    930     unset -nocomplain callbackResult callbackResults db fileName
   931         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
   932         -System.Data.SQLite SQLiteInterop\
          931  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
          932  +compile.EMIT SQLite System.Data.SQLite SQLiteInterop\
   933    933   defineConstant.System.Data.SQLite.INTEROP_SESSION_EXTENSION} -result \
   934    934   {{{TableName t1 NumberOfColumns 2 OperationCode Delete Indirect False\
   935    935   PrimaryKeyColumns {[True, False]} OldValue 0 1 NewValue 0 <nullObject>\
   936    936   ConflictValue 0 <nullObject> OldValue 1 {"inserted: Alpha Bravo Charlie Delta\
   937    937   Echo"} NewValue 1 <nullObject> ConflictValue 1 <nullObject>} {TableName t1\
   938    938   NumberOfColumns 2 OperationCode Insert Indirect False PrimaryKeyColumns {[True,\
   939    939   False]} OldValue 0 <nullObject> NewValue 0 3 ConflictValue 0 <nullObject>\
................................................................................
  1007   1007     catch {
  1008   1008       foreach callbackResult $callbackResults {
  1009   1009         catch {object dispose $callbackResult}
  1010   1010       }
  1011   1011     }
  1012   1012   
  1013   1013     unset -nocomplain callbackResult callbackResults db fileName
  1014         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
  1015         -System.Data.SQLite SQLiteInterop\
         1014  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
         1015  +compile.EMIT SQLite System.Data.SQLite SQLiteInterop\
  1016   1016   defineConstant.System.Data.SQLite.INTEROP_SESSION_EXTENSION} -result \
  1017   1017   {{{TableName t1 NumberOfColumns 2 OperationCode Delete Indirect False\
  1018   1018   PrimaryKeyColumns {[True, False]} OldValue 0 1 NewValue 0 <nullObject>\
  1019   1019   ConflictValue 0 <nullObject> OldValue 1 {"inserted: Alpha Bravo Charlie Delta\
  1020   1020   Echo"} NewValue 1 <nullObject> ConflictValue 1 <nullObject>} {TableName t1\
  1021   1021   NumberOfColumns 2 OperationCode Insert Indirect False PrimaryKeyColumns {[True,\
  1022   1022   False]} OldValue 0 <nullObject> NewValue 0 3 ConflictValue 0 <nullObject>\
................................................................................
  1081   1081     catch {
  1082   1082       foreach callbackResult $callbackResults {
  1083   1083         catch {object dispose $callbackResult}
  1084   1084       }
  1085   1085     }
  1086   1086   
  1087   1087     unset -nocomplain callbackResult callbackResults db fileName
  1088         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
  1089         -System.Data.SQLite SQLiteInterop\
         1088  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
         1089  +compile.EMIT SQLite System.Data.SQLite SQLiteInterop\
  1090   1090   defineConstant.System.Data.SQLite.INTEROP_SESSION_EXTENSION} -result \
  1091   1091   {{{TableName t1 NumberOfColumns 2 OperationCode Delete Indirect False\
  1092   1092   PrimaryKeyColumns {[True, False]} OldValue 0 1 NewValue 0 <nullObject>\
  1093   1093   ConflictValue 0 <nullObject> OldValue 1 <nullObject> NewValue 1 <nullObject>\
  1094   1094   ConflictValue 1 <nullObject>} {TableName t1 NumberOfColumns 2 OperationCode\
  1095   1095   Insert Indirect False PrimaryKeyColumns {[True, False]} OldValue 0 <nullObject>\
  1096   1096   NewValue 0 3 ConflictValue 0 <nullObject> OldValue 1 <nullObject> NewValue 1\
................................................................................
  1164   1164     catch {
  1165   1165       foreach callbackResult $callbackResults {
  1166   1166         catch {object dispose $callbackResult}
  1167   1167       }
  1168   1168     }
  1169   1169   
  1170   1170     unset -nocomplain callbackResult callbackResults db fileName
  1171         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
  1172         -System.Data.SQLite SQLiteInterop\
         1171  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
         1172  +compile.EMIT SQLite System.Data.SQLite SQLiteInterop\
  1173   1173   defineConstant.System.Data.SQLite.INTEROP_SESSION_EXTENSION} -result \
  1174   1174   {{{TableName t1 NumberOfColumns 2 OperationCode Delete Indirect False\
  1175   1175   PrimaryKeyColumns {[True, False]} OldValue 0 1 NewValue 0 <nullObject>\
  1176   1176   ConflictValue 0 <nullObject> OldValue 1 <nullObject> NewValue 1 <nullObject>\
  1177   1177   ConflictValue 1 <nullObject>} {TableName t1 NumberOfColumns 2 OperationCode\
  1178   1178   Insert Indirect False PrimaryKeyColumns {[True, False]} OldValue 0 <nullObject>\
  1179   1179   NewValue 0 3 ConflictValue 0 <nullObject> OldValue 1 <nullObject> NewValue 1\
................................................................................
  1267   1267     catch {
  1268   1268       foreach callbackResult $callbackResults {
  1269   1269         catch {object dispose $callbackResult}
  1270   1270       }
  1271   1271     }
  1272   1272   
  1273   1273     unset -nocomplain callbackResult callbackResults db fileName
  1274         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
  1275         -System.Data.SQLite SQLiteInterop\
         1274  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
         1275  +compile.EMIT SQLite System.Data.SQLite SQLiteInterop\
  1276   1276   defineConstant.System.Data.SQLite.INTEROP_SESSION_EXTENSION} -result \
  1277   1277   {06631bf3545dba83b25db5142afc4d229544ed55}}
  1278   1278   
  1279   1279   ###############################################################################
  1280   1280   
  1281   1281   runTest {test session-1.10.1 {change group (memory)} -setup {
  1282   1282     setupDb [set fileName session-1.10.1.db]

Changes to Tests/speed.eagle.

   111    111     set result
   112    112   } -cleanup {
   113    113     cleanupDb $fileName
   114    114   
   115    115     unset -nocomplain time sql result char db fileName
   116    116   } -time true -constraints {eagle monoBug28 command.sql compile.DATA SQLite\
   117    117   System.Data.SQLite} -match regexp -result "^\\\{-9223372036854775808 0\
   118         -9223372036854775807\\\} \\\{-(?:Infinity|\u221E) 0 (?:Infinity|\u221E)\\\}\
   119         -\\\{1 1\\.1 1048576\\\} \\\{1 \\\{1 35 69 103 137\\\} 1048576\\\}$"}
          118  +9223372036854775807\\\}\
          119  +\\\{-(?:Infinity|\u221E|1\\.7976931348623157(?:E|e)\\+308) 0\
          120  +(?:Infinity|\u221E|1\\.7976931348623157(?:E|e)\\+308)\\\} \\\{1 1\\.1\
          121  +1048576\\\} \\\{1 \\\{1 35 69 103 137\\\} 1048576\\\}$"}
   120    122   
   121    123   ###############################################################################
   122    124   
   123    125   runTest {test speed-1.2 {SQLiteDataReader speed testing} -setup {
   124    126     setupDb [set fileName [appendArgs speed-1.2- [pid] .db]]
   125    127   
   126    128     sql execute $db "CREATE TABLE t1(w INTEGER);"

Changes to Tests/stress.eagle.

   279    279         }
   280    280       }
   281    281     }
   282    282   
   283    283     #############################################################################
   284    284   
   285    285     proc useMem { ptr size } {
   286         -    if {[isWindows] && ![isMono]} then {
          286  +    #
          287  +    # NOTE: This procedure does nothing on non-Windows operating systems.  It
          288  +    #       also does nothing when running on Mono or .NET Core, due to their
          289  +    #       lack of the (internal, undocumented) ZeroMemory method.
          290  +    #
          291  +    if {[isWindows] && ![isMono] && ![isDotNetCore]} then {
   287    292         #
   288    293         # HACK: The type signature of the ZeroMemory method changed as of the
   289    294         #       .NET Framework 4.5.  The second argument went from being of
   290    295         #       type UInt to type UIntPtr.
   291    296         #
   292    297         if {[haveConstraint dotNet40] && \
   293    298             [haveConstraint dotNet45OrHigher]} then {
................................................................................
   354    359         object invoke System.Diagnostics.Trace.Listeners Remove $::logListener
   355    360         $::logListener Close
   356    361       }
   357    362   
   358    363       #
   359    364       # NOTE: Copy the trace listener log file to the main test log file.
   360    365       #
   361         -    tlog "---- BEGIN TRACE LISTENER OUTPUT\n"
   362         -    tlog [readFile $fileName]
   363         -    tlog "\n---- END TRACE LISTENER OUTPUT\n"
          366  +    if {[file exists $fileName]} then {
          367  +      tlog "---- BEGIN TRACE LISTENER OUTPUT\n"
          368  +      tlog [readFile $fileName]
          369  +      tlog "\n---- END TRACE LISTENER OUTPUT\n"
          370  +    }
   364    371   
   365    372       #
   366    373       # NOTE: Delete the trace listener log file because its contents have
   367    374       #       been copied to the main test log file.
   368    375       #
   369    376       cleanupFile $fileName
   370    377   
................................................................................
  1672   1679       sql execute $db "CREATE TABLE IF NOT EXISTS t3(x);"
  1673   1680   
  1674   1681       sql execute $srcDb "CREATE INDEX IF NOT EXISTS i1 ON t1(y);"
  1675   1682       sql execute $db "CREATE INDEX IF NOT EXISTS i1 ON t1(y);"
  1676   1683   
  1677   1684       foreach index(1) [lsort -integer $workloadNames(enabled)] {
  1678   1685         set workloadCallbacks($index(1)) [list \
  1679         -          apply $workload($index(1)) $fileName(1) $fileName(2) t1 $count(1) \
  1680         -          $count(3) $count(4) $count(5) $count(6) $count(7) $count(8)]
         1686  +          apply $workload($index(1)) $fileName(1) $fileName(2) t1 \
         1687  +          $count(1) $count(3) $count(4) $count(5) $count(6) $count(7) \
         1688  +          $count(8)]
  1681   1689   
  1682         -      set thread($index(1)) [object create -alias System.Threading.Thread \
  1683         -          $workloadCallbacks($index(1)) 1048576]
         1690  +      set thread($index(1)) [createThread $workloadCallbacks($index(1)) \
         1691  +          false 1048576]
  1684   1692   
  1685   1693         $thread($index(1)) Name [appendArgs \
  1686   1694             [file rootname [file tail $fileName(2)]] " #" $index(1)]
  1687   1695   
  1688   1696         if {[info exists priority($index(1))]} then {
  1689   1697           $thread($index(1)) Priority $priority($index(1))
  1690   1698         }
  1691   1699       }
  1692   1700   
  1693   1701       foreach index(1) [array names thread] {
  1694         -      $thread($index(1)) Start
         1702  +      startThread $thread($index(1))
  1695   1703       }
  1696   1704   
  1697   1705       $event Set; # GO
  1698   1706   
  1699   1707       foreach index(1) [array names thread] {
  1700   1708         $thread($index(1)) Join
  1701   1709       }

Changes to Tests/thread.eagle.

    61     61   #
    62     62   if {![info exists count(4)]} then {
    63     63     set count(4) 1000
    64     64   }
    65     65   
    66     66   ###############################################################################
    67     67   
           68  +#
           69  +# NOTE: This test is disabled for .NET Core due to its lack of support for
           70  +#       the Thread.Abort method (i.e. throws PlatformNotSupportedException
           71  +#       when called).
           72  +#
    68     73   runTest {test thread-1.1 {Thread.Abort() impact on native resources} -setup {
    69     74     setupDb [set fileName thread-1.1.db]
    70     75   
    71     76     tputs $test_channel [appendArgs \
    72     77         "---- using " $count(1) " test threads (with one master thread)\n"]
    73     78   
    74     79     tputs $test_channel [appendArgs \
................................................................................
   454    459         [collectGarbage $test_channel [expr {$count(1) * 1000}] false] \
   455    460         [getSQLiteHandleCounts $test_channel] \
   456    461         [reportSQLiteResources $test_channel]
   457    462   } -cleanup {
   458    463     cleanupDb $fileName
   459    464   
   460    465     unset -nocomplain result results errors code sql dataSource id db fileName
   461         -} -time true -constraints {eagle command.object monoBug28 monoCrash211\
   462         -monoCrash42 monoBug46 command.sql compile.DATA SQLite System.Data.SQLite\
   463         -compileCSharp} -match regexp -result [appendArgs "^Ok\
   464         -System#CodeDom#Compiler#CompilerResults#\\d+ \\{\\} 0 \\{\\d+ \\d+ " $count(1) \
   465         -"\\} \\{\\} \\{" $handle_counts "\\} " $memory_used \$]}
          466  +} -time true -constraints [fixConstraints {eagle command.object monoBug28\
          467  +monoCrash211 monoCrash42 monoBug46 command.sql compile.DATA SQLite\
          468  +System.Data.SQLite compileCSharp !dotNetCore}] -match regexp -result \
          469  +[appendArgs "^Ok System#CodeDom#Compiler#CompilerResults#\\d+ \\{\\} 0 \\{\\d+\
          470  +\\d+ " $count(1) "\\} \\{\\} \\{" $handle_counts "\\} " $memory_used \$]}
   466    471   
   467    472   ###############################################################################
   468    473   
   469    474   unset -nocomplain count
   470    475   
   471    476   ###############################################################################
   472    477   
   473    478   unset -nocomplain memory_used handle_counts
   474    479   
   475    480   ###############################################################################
   476    481   
   477    482   runSQLiteTestEpilogue
   478    483   runTestEpilogue

Changes to Tests/tkt-0e48e80333.eagle.

   117    117   
   118    118     moveEagleShellMdaConfig true
   119    119   } -constraints {eagle dotNet testExec command.object monoBug28 command.sql\
   120    120   compile.DATA SQLite System.Data.SQLite} -result {0}}
   121    121   
   122    122   ###############################################################################
   123    123   
          124  +#
          125  +# HACK: This test is non-portable (e.g. to Mono) due to its use of Managed
          126  +#       Debugging Assistants (MDAs), which are only implemented by the full
          127  +#       .NET Framework.
          128  +#
   124    129   runTest {test tkt-0e48e80333-1.2 {delegate MDA on pooled close} -setup {
   125    130     moveEagleShellMdaConfig false
   126    131   
   127    132     saveEagleShellEnvironment
   128    133     saveMdaConfigEnvironment
   129    134   
   130    135     setupDb [set fileName tkt-0e48e80333-1.2.db]
................................................................................
   309    314     unset -nocomplain code output error scriptFileName configFileName
   310    315     unset -nocomplain db fileName
   311    316   
   312    317     restoreMdaConfigEnvironment
   313    318     restoreEagleShellEnvironment
   314    319   
   315    320     moveEagleShellMdaConfig true
   316         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
   317         -System.Data.SQLite compileCSharp} -match regexp -result {^0 \{Ok\
          321  +} -constraints {eagle dotNet command.object monoBug28 command.sql compile.DATA\
          322  +SQLite System.Data.SQLite compileCSharp} -match regexp -result {^0 \{Ok\
   318    323   System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 \{\} 0 \d+\}$}}
   319    324   
   320    325   ###############################################################################
   321    326   
   322    327   runSQLiteTestEpilogue
   323    328   runTestEpilogue

Changes to Tests/tkt-5cee5409f8.eagle.

    16     16   ###############################################################################
    17     17   
    18     18   package require System.Data.SQLite.Test
    19     19   runSQLiteTestPrologue
    20     20   
    21     21   ###############################################################################
    22     22   
           23  +#
           24  +# NOTE: This test is disabled for .NET Core due to its lack of support for
           25  +#       distributed transactions.
           26  +#
    23     27   runTest {test tkt-5cee5409f8-1.1 {asynchronous transaction handling} -setup {
    24     28     setupDb [set fileName tkt-5cee5409f8-1.1.db]
    25     29   } -body {
    26     30     sql execute $db "CREATE TABLE t1(x INTEGER);"
    27     31   
    28     32     set id [object invoke Interpreter.GetActive NextId]
    29     33     set dataSource [file join [getDatabaseDirectory] $fileName]
................................................................................
   205    209         } result] : [set result ""]}] \
   206    210         [expr {[lindex $result 0] > 0}] \
   207    211         [expr {[lindex $result 1] > 0}]
   208    212   } -cleanup {
   209    213     cleanupDb $fileName
   210    214   
   211    215     unset -nocomplain result results errors code dataSource id db fileName
   212         -} -constraints {eagle command.object monoBug211 monoBug510 command.sql\
   213         -compile.DATA SQLite System.Data.SQLite compileCSharp} -match regexp -result \
   214         -{^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0 True True$}}
          216  +} -constraints [fixConstraints {eagle command.object monoBug211 monoBug510\
          217  +command.sql compile.DATA SQLite System.Data.SQLite compileCSharp !dotNetCore}] \
          218  +-match regexp -result {^Ok System#CodeDom#Compiler#CompilerResults#\d+ \{\} 0\
          219  +True True$}}
   215    220   
   216    221   ###############################################################################
   217    222   
   218    223   runSQLiteTestEpilogue
   219    224   runTestEpilogue

Changes to Tests/tkt-84718e79fa.eagle.

    26     26   
    27     27   runTest {test tkt-84718e79fa-1.1 {SQLiteConvert thread safety} -setup {
    28     28     proc threadStart { args } {
    29     29       lappend ::results [sql execute -execute reader -format list $::db \
    30     30           "SELECT x FROM t1;"]
    31     31     }
    32     32   
    33         -  object import System.Threading
    34         -
    35     33     setupDb [set fileName tkt-84718e79fa-1.1.db]
    36     34   } -body {
    37     35     sql execute $db "CREATE TABLE t1(x INTEGER PRIMARY KEY ASC);"
    38     36     sql execute $db "INSERT INTO t1 (x) VALUES(1);"
    39     37   
    40     38     for {set i 0} {$i < $c} {incr i} {
    41         -    set t($i) [object create -alias Thread threadStart 1048576]
           39  +    set t($i) [createThread threadStart false 1048576]
    42     40     }
    43     41   
    44     42     set results [list]
    45     43   
    46     44     for {set i 0} {$i < $c} {incr i} {
    47         -    $t($i) Start
           45  +    startThread $t($i)
    48     46     }
    49     47   
    50     48     after 4000; # wait for other threads to do something...
    51     49   
    52     50     for {set i 0} {$i < $c} {incr i} {
    53     51       $t($i) Join
    54     52     }
    55     53   
    56     54     set results
    57     55   } -cleanup {
    58     56     cleanupDb $fileName
    59     57   
    60         -  object unimport -importpattern System.Threading
    61         -
    62     58     for {set i 0} {$i < $c} {incr i} {
    63     59       if {[info exists t($i)] && [cleanupThread $t($i)]} then {
    64     60         unset t($i)
    65     61       }
    66     62     }
    67     63   
    68     64     catch {object removecallback threadStart}
    69     65   
    70     66     unset -nocomplain results t i c db fileName
    71     67   
    72     68     rename threadStart ""
    73         -} -constraints {eagle command.object shell monoBug28 command.sql compile.DATA\
    74         -SQLite System.Data.SQLite} -result [lrepeat $c 1]}
           69  +} -constraints {eagle command.object dotNetCoreOrShell monoBug28 command.sql\
           70  +compile.DATA SQLite System.Data.SQLite} -result [lrepeat $c 1]}
    75     71   
    76     72   ###############################################################################
    77     73   
    78     74   unset -nocomplain c
    79     75   
    80     76   ###############################################################################
    81     77   
    82     78   runSQLiteTestEpilogue
    83     79   runTestEpilogue

Changes to Tests/types.eagle.

   338    338   
   339    339       cleanupDb $fileName
   340    340   
   341    341       unset -nocomplain buffer typeCallbacks callback value list
   342    342       unset -nocomplain result connection db fileName
   343    343       unset -nocomplain typeName methodName isArray
   344    344     } -constraints {eagle command.object monoBug28 command.sql compile.DATA\
   345         -SQLite System.Data.SQLite} -result $expectedResult}
          345  +compile.EMIT SQLite System.Data.SQLite} -result $expectedResult}
   346    346   
   347    347     rename readValueCallback2 ""
   348    348   }
   349    349   
   350    350   ###############################################################################
   351    351   
   352    352   object invoke Interpreter.GetActive DateTimeFormat $savedDateTimeFormat
................................................................................
   354    354   
   355    355   object invoke Interpreter.GetActive DateTimeKind $savedDateTimeKind
   356    356   unset -nocomplain savedDateTimeKind
   357    357   
   358    358   ###############################################################################
   359    359   
   360    360   unset -nocomplain i readArgs params typeName methodName isArray propertyName \
   361         -    isRequired expectedResults expectedResult
          361  +    isRequired value expectedResults expectedResult
   362    362   
   363    363   ###############################################################################
   364    364   
   365    365   runTest {test types-3.1 {bind callback (incomplete)} -setup {
   366    366     unset -nocomplain log
   367    367   
   368    368     setupDb [set fileName types-3.1.db] "" "" "" \
................................................................................
   399    399     catch {object removecallback $callback}
   400    400   
   401    401     freeDbConnection
   402    402   
   403    403     cleanupDb $fileName
   404    404   
   405    405     unset -nocomplain result typeCallbacks callback log connection db fileName
   406         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
   407         -System.Data.SQLite} -result {{{convert true} {command true} {flags\
   408         -{UseConnectionBindValueCallbacks, UseParameterNameForTypeName}} {parameter\
   409         -true} {typeName Special} {index 1} {userData 0}} 1234}}
          406  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
          407  +compile.EMIT SQLite System.Data.SQLite} -result {{{convert true} {command true}\
          408  +{flags {UseConnectionBindValueCallbacks, UseParameterNameForTypeName}}\
          409  +{parameter true} {typeName Special} {index 1} {userData 0}} 1234}}
   410    410   
   411    411   ###############################################################################
   412    412   
   413    413   runTest {test types-3.2 {bind callback (complete)} -setup {
   414    414     unset -nocomplain log
   415    415   
   416    416     setupDb [set fileName types-3.2.db] "" "" "" \
................................................................................
   447    447     catch {object removecallback $callback}
   448    448   
   449    449     freeDbConnection
   450    450   
   451    451     cleanupDb $fileName
   452    452   
   453    453     unset -nocomplain result typeCallbacks callback log connection db fileName
   454         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
   455         -System.Data.SQLite} -result {{{convert true} {command true} {flags\
   456         -{UseConnectionBindValueCallbacks, UseParameterNameForTypeName}} {parameter\
   457         -true} {typeName Special} {index 1} {userData 1}} {}}}
          454  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
          455  +compile.EMIT SQLite System.Data.SQLite} -result {{{convert true} {command true}\
          456  +{flags {UseConnectionBindValueCallbacks, UseParameterNameForTypeName}}\
          457  +{parameter true} {typeName Special} {index 1} {userData 1}} {}}}
   458    458   
   459    459   ###############################################################################
   460    460   
   461    461   runTest {test types-3.3 {bind callback (modify/incomplete)} -setup {
   462    462     unset -nocomplain log
   463    463   
   464    464     setupDb [set fileName types-3.3.db] "" "" "" \
................................................................................
   495    495     catch {object removecallback $callback}
   496    496   
   497    497     freeDbConnection
   498    498   
   499    499     cleanupDb $fileName
   500    500   
   501    501     unset -nocomplain result typeCallbacks callback log connection db fileName
   502         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
   503         -System.Data.SQLite} -result {{{convert true} {command true} {flags\
   504         -{UseConnectionBindValueCallbacks, UseParameterNameForTypeName}} {parameter\
   505         -true} {typeName Special} {index 1} {userData 2}} custom}}
          502  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
          503  +compile.EMIT SQLite System.Data.SQLite} -result {{{convert true} {command true}\
          504  +{flags {UseConnectionBindValueCallbacks, UseParameterNameForTypeName}}\
          505  +{parameter true} {typeName Special} {index 1} {userData 2}} custom}}
   506    506   
   507    507   ###############################################################################
   508    508   
   509    509   runTest {test types-4.1 {read callback (exception)} -setup {
   510    510     unset -nocomplain log
   511    511   
   512    512     setupDb [set fileName types-4.1.db] "" "" "" \
................................................................................
   547    547   
   548    548     freeDbConnection
   549    549   
   550    550     cleanupDb $fileName
   551    551   
   552    552     unset -nocomplain error result typeCallbacks callback log connection db \
   553    553         fileName
   554         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
   555         -System.Data.SQLite} -result {1 {reading of value canceled} 0 1 {{convert true}\
   556         -{dataReader true} {flags UseConnectionReadValueCallbacks} {eventArgs true}\
   557         -{typeName SPECIAL} {index 0} {userData 3}}}}
          554  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
          555  +compile.EMIT SQLite System.Data.SQLite} -result {1 {reading of value canceled}\
          556  +0 1 {{convert true} {dataReader true} {flags UseConnectionReadValueCallbacks}\
          557  +{eventArgs true} {typeName SPECIAL} {index 0} {userData 3}}}}
   558    558   
   559    559   ###############################################################################
   560    560   
   561    561   runTest {test types-5.1 {bind callback (exception)} -setup {
   562    562     unset -nocomplain log
   563    563   
   564    564     setupDb [set fileName types-5.1.db] "" "" "" \
................................................................................
   597    597     catch {object removecallback $callback}
   598    598   
   599    599     freeDbConnection
   600    600   
   601    601     cleanupDb $fileName
   602    602   
   603    603     unset -nocomplain result typeCallbacks callback log connection db fileName
   604         -} -constraints {eagle command.object monoBug28 command.sql compile.DATA SQLite\
   605         -System.Data.SQLite} -result {{{convert true} {command true} {flags\
   606         -{UseConnectionBindValueCallbacks, UseParameterNameForTypeName}} {parameter\
   607         -true} {typeName Special} {index 1} {userData 3}} {}}}
          604  +} -constraints {eagle command.object monoBug28 command.sql compile.DATA\
          605  +compile.EMIT SQLite System.Data.SQLite} -result {{{convert true} {command true}\
          606  +{flags {UseConnectionBindValueCallbacks, UseParameterNameForTypeName}}\
          607  +{parameter true} {typeName Special} {index 1} {userData 3}} {}}}
   608    608   
   609    609   ###############################################################################
   610    610   
   611    611   catch {eval object dispose [info objects System#Boolean#*]}
   612    612   
   613    613   ###############################################################################
   614    614   

Changes to data/exclude_bin.txt.

     1      1   *.done
     2      2   *.exp
     3      3   *.ilk
            4  +*.json
     4      5   *.lib
     5      6   *.manifest
     6      7   *.map
     7      8   *.mda.config
     8      9   *.netmodule
     9     10   *.txt
    10     11   *32.exe

Changes to data/exclude_full_src.txt.

     9      9   *.suo
    10     10   *.user
    11     11   *.zip
    12     12   .fossil-settings/*
    13     13   _FOSSIL_
    14     14   bin/*
    15     15   Doc/Output/*
    16         -Externals/Eagle/bin/EntityFramework.*
    17         -Externals/Eagle/bin/SQLite.Interop.*
    18         -Externals/Eagle/bin/sqlite3.*
    19         -Externals/Eagle/bin/System.*
    20         -Externals/Eagle/bin/Win32/*
           16  +Externals/Eagle/bin/netFramework40/EntityFramework.*
           17  +Externals/Eagle/bin/netFramework40/SQLite.Interop.*
           18  +Externals/Eagle/bin/netFramework40/sqlite3.*
           19  +Externals/Eagle/bin/netFramework40/System.*
           20  +Externals/Eagle/bin/netFramework40/Win32/*
           21  +Externals/Eagle/bin/netStandard20/EntityFramework.*
           22  +Externals/Eagle/bin/netStandard20/SQLite.Interop.*
           23  +Externals/Eagle/bin/netStandard20/sqlite3.*
           24  +Externals/Eagle/bin/netStandard20/System.*
           25  +Externals/Eagle/bin/netStandard20/Win32/*
    21     26   Externals/EntityFramework/*
    22     27   Externals/HtmlHelp/*
    23     28   Externals/MSVCPP/*
    24     29   Externals/NDoc3/*
    25     30   obj/*
    26     31   Setup/Output/*
    27     32   Setup/set_user_*.bat

Changes to data/exclude_src.txt.

     9      9   *.suo
    10     10   *.user
    11     11   *.zip
    12     12   .fossil-settings/*
    13     13   _FOSSIL_
    14     14   bin/*
    15     15   Doc/Output/*
    16         -Externals/Eagle/bin/Eagle.dll
    17         -Externals/Eagle/bin/EagleShell.exe
    18         -Externals/Eagle/bin/EagleShell32.exe
    19         -Externals/Eagle/bin/EntityFramework.*
    20         -Externals/Eagle/bin/SQLite.Interop.*
    21         -Externals/Eagle/bin/sqlite3.*
    22         -Externals/Eagle/bin/System.*
    23         -Externals/Eagle/bin/Win32/*
    24         -Externals/Eagle/bin/x64/*
    25         -Externals/Eagle/bin/x86/*
           16  +Externals/Eagle/bin/netFramework40/Eagle.dll
           17  +Externals/Eagle/bin/netFramework40/EagleShell.exe
           18  +Externals/Eagle/bin/netFramework40/EagleShell32.exe
           19  +Externals/Eagle/bin/netFramework40/EntityFramework.*
           20  +Externals/Eagle/bin/netFramework40/SQLite.Interop.*
           21  +Externals/Eagle/bin/netFramework40/sqlite3.*
           22  +Externals/Eagle/bin/netFramework40/System.*
           23  +Externals/Eagle/bin/netFramework40/Win32/*
           24  +Externals/Eagle/bin/netFramework40/x64/*
           25  +Externals/Eagle/bin/netFramework40/x86/*
           26  +Externals/Eagle/bin/netStandard20/Eagle.dll
           27  +Externals/Eagle/bin/netStandard20/EagleShell.dll
           28  +Externals/Eagle/bin/netStandard20/EagleShell.runtimeconfig.json
           29  +Externals/Eagle/bin/netStandard20/EntityFramework.*
           30  +Externals/Eagle/bin/netStandard20/SQLite.Interop.*
           31  +Externals/Eagle/bin/netStandard20/sqlite3.*
           32  +Externals/Eagle/bin/netStandard20/System.*
           33  +Externals/Eagle/bin/netStandard20/Win32/*
    26     34   Externals/Eagle/lib/Eagle1.0/auxiliary.eagle
    27     35   Externals/Eagle/lib/Eagle1.0/compat.eagle
    28     36   Externals/Eagle/lib/Eagle1.0/csharp.eagle
    29     37   Externals/Eagle/lib/Eagle1.0/database.eagle
    30     38   Externals/Eagle/lib/Eagle1.0/embed.eagle
    31     39   Externals/Eagle/lib/Eagle1.0/exec.eagle
    32     40   Externals/Eagle/lib/Eagle1.0/file1.eagle
................................................................................
    52     60   Externals/Eagle/lib/Eagle1.0/update.eagle
    53     61   Externals/Eagle/lib/Eagle1.0/word.tcl
    54     62   Externals/Eagle/lib/Test1.0/*
    55     63   Externals/EntityFramework/*
    56     64   Externals/HtmlHelp/*
    57     65   Externals/MSVCPP/*
    58     66   Externals/NDoc3/*
           67  +Externals/ResGen/*
    59     68   Externals/vswhere/*
    60     69   obj/*
    61     70   Setup/Output/*
    62     71   Setup/set_user_*.bat
    63     72   SQLite.Designer/obj/*
    64     73   SQLite.Designer/Properties/*
    65     74   SQLite.Designer/VSDesign/*

Changes to lib/System.Data.SQLite/common.eagle.

   144    144               #
   145    145               return 2008; # TODO: Good "fallback" default?
   146    146             }
   147    147           }
   148    148         }
   149    149       }
   150    150   
          151  +    proc getBuildNativeYear {} {
          152  +      if {[info exists ::test_native_year] && \
          153  +          [string length $::test_native_year] > 0} then {
          154  +        #
          155  +        # NOTE: Use the specified test year for native binaries.  If this
          156  +        #       variable is not set, the value returned by [getBuildYear]
          157  +        #       will be used.
          158  +        #
          159  +        return $::test_native_year
          160  +      } else {
          161  +        #
          162  +        # NOTE: Fallback on the (normal) build year for managed binaries.
          163  +        #
          164  +        return [getBuildYear]
          165  +      }
          166  +    }
          167  +
   151    168       #
   152    169       # NOTE: This procedure is only used when adding shimmed test constraints.
   153    170       #
   154    171       proc getBuildClrVersion {} {
   155    172         if {[info exists ::test_clr] && [string length $::test_clr] > 0} then {
   156    173           #
   157    174           # NOTE: Use the specified test version for the CLR.  If this variable
................................................................................
   209    226           # NOTE: Use the specified list of test years.
   210    227           #
   211    228           return $::test_years
   212    229         } else {
   213    230           #
   214    231           # NOTE: Use the default list of test years (i.e. all).
   215    232           #
   216         -        return [list 2005 2008 2010 2012 2013 2015 2017]
          233  +        return [list 2005 2008 2010 2012 2013 2015 2017 NetStandard20]
   217    234         }
   218    235       }
   219    236   
   220    237       proc getBuildNetFx {} {
   221    238         #
   222    239         # NOTE: See if the test .NET Framework setting has been overridden by
   223    240         #       the user (e.g. on the command line).
................................................................................
   263    280               }
   264    281               2015 {
   265    282                 return netFx46; # TODO: Or "netFx461" / "netFx462"?
   266    283               }
   267    284               2017 {
   268    285                 return netFx47; # TODO: Or "netFx471"?
   269    286               }
          287  +            NetStandard20 {
          288  +              return netStandard20
          289  +            }
   270    290               default {
   271    291                 return netFx35; # TODO: Good "fallback" default?
   272    292               }
   273    293             }
   274    294           }
   275    295         }
   276    296       }
................................................................................
   389    409         } else {
   390    410           #
   391    411           # NOTE: Use the default list of test configurations.
   392    412           #
   393    413           return [list Debug Release]
   394    414         }
   395    415       }
          416  +
          417  +    proc getBuildExtra {} {
          418  +      if {[info exists ::test_extra] && \
          419  +          [string length $::test_extra] > 0} then {
          420  +        #
          421  +        # NOTE: Use the specified extra output directory.
          422  +        #
          423  +        return $::test_extra
          424  +      } elseif {[isDotNetCore]} then {
          425  +        #
          426  +        # NOTE: Running on .NET Core, use the extra output directory for
          427  +        #       library files.
          428  +        #
          429  +        return netstandard2.0
          430  +      } else {
          431  +        #
          432  +        # NOTE: No extra output directory is required.
          433  +        #
          434  +        return ""
          435  +      }
          436  +    }
          437  +
          438  +    proc getBuildExtras {} {
          439  +      #
          440  +      # NOTE: See if the list of extra output directories has been overridden
          441  +      #       by the user (e.g. on the command line).
          442  +      #
          443  +      if {[info exists ::test_extras] && \
          444  +          [llength $::test_extras] > 0} then {
          445  +        #
          446  +        # NOTE: Use the specified list of extra output directories.
          447  +        #
          448  +        return $::test_extras
          449  +      } elseif {[isDotNetCore]} then {
          450  +        #
          451  +        # NOTE: Running on .NET Core, prioritize its extra output directory
          452  +        #       for library files.
          453  +        #
          454  +        return [list netstandard2.0 ""]
          455  +      } else {
          456  +        #
          457  +        # NOTE: Use default list of extra output directories, which is one
          458  +        #       empty string (no-op).
          459  +        #
          460  +        return [list ""]
          461  +      }
          462  +    }
   396    463   
   397    464       proc getBuildBaseDirectory {} {
   398    465         #
   399    466         # NOTE: Figure out the base directory where all the builds should be
   400    467         #       located.  This will be the directory that contains the actual
   401    468         #       build output directory (e.g. parent of "bin").
   402    469         #
................................................................................
   632    699         #       we have everything we need.
   633    700         #
   634    701         if {$native} then {
   635    702           return true
   636    703         }
   637    704   
   638    705         #
   639         -      # NOTE: If the machine name is unavailable, there is nothign else we
          706  +      # NOTE: If the machine name is unavailable, there is nothing else we
   640    707         #       can do.
   641    708         #
   642    709         if {![info exists ::tcl_platform(machine)]} then {
   643    710           return false
   644    711         }
   645    712   
   646    713         #
................................................................................
   720    787         if {[string length $varName] > 0} then {
   721    788           upvar 1 $varName $varName
   722    789         }
   723    790   
   724    791         return [isBuildAvailable "" $directory $varName]
   725    792       }
   726    793   
   727         -    proc joinBuildDirectory { native path year platform configuration } {
          794  +    proc joinBuildDirectory { native path year platform configuration extra } {
   728    795         #
   729    796         # NOTE: Figure out and then return the fully qualified path to the build
   730    797         #       directory based on all the arguments provided by our caller.
   731    798         #
   732    799         if {$native} then {
   733         -        return [file join $path bin $year $platform $configuration]
          800  +        return [file join $path bin $year $platform $configuration $extra]
   734    801         } else {
   735         -        return [file join $path bin $year $configuration bin]
          802  +        return [file join $path bin $year $configuration bin $extra]
   736    803         }
   737    804       }
   738    805   
   739    806       proc getBuildDirectory { managedOnly } {
   740    807         #
   741    808         # NOTE: See if the "native" runtime option has been set.  If so, use the
   742    809         #       directory for the mixed-mode assembly (a.k.a. the native interop
................................................................................
   801    868           #       need to be adjusted accordingly to actually run the test suite.
   802    869           #       Refer to the comments in [getBuildYear] for more information on
   803    870           #       how to set this variable.
   804    871           #
   805    872           set native [expr {!$managedOnly && [hasRuntimeOption native]}]
   806    873   
   807    874           return [joinBuildDirectory $native [getBuildBaseDirectory] \
   808         -            [getBuildYear] [getBuildPlatform $native] [getBuildConfiguration]]
          875  +            [expr {$managedOnly ? [getBuildYear] : [getBuildNativeYear]}] \
          876  +            [getBuildPlatform $native] [getBuildConfiguration] \
          877  +            [expr {$managedOnly ? [getBuildExtra] : ""}]]
   809    878         }
   810    879       }
   811    880   
   812    881       proc getReleaseVersion {} {
   813    882         #
   814    883         # NOTE: Figure out the release version for use with the build directory
   815    884         #       when checking for available releases.
................................................................................
  1607   1676         #       [primarily] a native build; therefore, it always matches.
  1608   1677         #
  1609   1678         if {[string length $platform] == 0} then {
  1610   1679           return true
  1611   1680         }
  1612   1681   
  1613   1682         #
  1614         -      # NOTE: If the machine name is unavailable, there is nothign else we
         1683  +      # NOTE: If the machine name is unavailable, there is nothing else we
  1615   1684         #       can do.
  1616   1685         #
  1617   1686         if {![info exists ::tcl_platform(machine)]} then {
  1618   1687           return false
  1619   1688         }
  1620   1689   
  1621   1690         #
................................................................................
  1706   1775         # NOTE: Check for every possible valid combination of values used when
  1707   1776         #       locating out the build output directory, showing each available
  1708   1777         #       build variation along the way.
  1709   1778         #
  1710   1779         foreach native [list false true] {
  1711   1780           foreach year [getBuildYears] {
  1712   1781             foreach configuration [getBuildConfigurations] {
  1713         -            #
  1714         -            # NOTE: Figure out the effective build platform.  This is
  1715         -            #       based on whether or not a [primarily] native build
  1716         -            #       is being used.  For [primarily] non-native builds,
  1717         -            #       this will be an empty string.
  1718         -            #
  1719         -            set platform [getBuildPlatform $native]
  1720         -
  1721         -            tputs $channel [appendArgs \
  1722         -                "---- checking for System.Data.SQLite build \"" [expr \
  1723         -                {$native ? "native/" : ""}] [expr {[string length \
  1724         -                $platform] > 0 ? [appendArgs $platform /] : ""}] $year \
  1725         -                / $configuration "\"... "]
  1726         -
  1727         -            #
  1728         -            # NOTE: Build the fully qualified directory where the necessary
  1729         -            #       components for System.Data.SQLite should be found.
  1730         -            #
  1731         -            set directory [joinBuildDirectory $native \
  1732         -                [getBuildBaseDirectory] $year $platform $configuration]
  1733         -
  1734         -            #
  1735         -            # NOTE: Do the necessary files exist?  Currently, no other steps
  1736         -            #       are taken to verify this build is actually viable.
  1737         -            #
  1738         -            if {[isBuildAvailable $native $directory]} then {
  1739         -              #
  1740         -              # NOTE: When in "select" mode, automatically select the first
  1741         -              #       available build of System.Data.SQLite and then return
  1742         -              #       immediately.
  1743         -              #
  1744         -              if {$select && [matchPlatform $platform]} then {
         1782  +            foreach extra [getBuildExtras] {
         1783  +              #
         1784  +              # NOTE: Figure out the effective build platform.  This is
         1785  +              #       based on whether or not a [primarily] native build
         1786  +              #       is being used.  For [primarily] non-native builds,
         1787  +              #       this will be an empty string.
         1788  +              #
         1789  +              set platform [getBuildPlatform $native]
         1790  +
         1791  +              tputs $channel [appendArgs \
         1792  +                  "---- checking for System.Data.SQLite build \"" [expr \
         1793  +                  {$native ? "native/" : ""}] [expr {[string length \
         1794  +                  $platform] > 0 ? [appendArgs $platform /] : ""}] $year \
         1795  +                  / $configuration "\"... "]
         1796  +
         1797  +              #
         1798  +              # NOTE: Build the fully qualified directory where the necessary
         1799  +              #       components for System.Data.SQLite should be found.
         1800  +              #
         1801  +              set directory [joinBuildDirectory $native \
         1802  +                  [getBuildBaseDirectory] $year $platform $configuration \
         1803  +                  $extra]
         1804  +
         1805  +              #
         1806  +              # NOTE: Do the necessary files exist?  Currently, no other steps
         1807  +              #       are taken to verify this build is actually viable.
         1808  +              #
         1809  +              if {[isBuildAvailable $native $directory]} then {
         1810  +                #
         1811  +                # NOTE: When in "select" mode, automatically select the first
         1812  +                #       available build of System.Data.SQLite and then return
         1813  +                #       immediately.
  1745   1814                   #
  1746         -                # NOTE: Manually override all the build directory selection
  1747         -                #       related test settings in order to force this build
  1748         -                #       of System.Data.SQLite to be used.
  1749         -                #
  1750         -                if {![changeNativeRuntimeOption $native]} then {
         1815  +                if {$select && [matchPlatform $platform]} then {
         1816  +                  #
         1817  +                  # NOTE: Manually override all the build directory selection
         1818  +                  #       related test settings in order to force this build
         1819  +                  #       of System.Data.SQLite to be used.
         1820  +                  #
         1821  +                  if {![changeNativeRuntimeOption $native]} then {
         1822  +                    tputs $channel [appendArgs \
         1823  +                        "no, failed to " [expr {$native ? "add" : "remove"}] \
         1824  +                        " the \"native\" runtime option\n"]
         1825  +
         1826  +                    return false
         1827  +                  }
         1828  +
         1829  +                  set ::test_year $year
         1830  +                  set ::test_platform $platform
         1831  +                  set ::test_configuration $configuration
         1832  +
  1751   1833                     tputs $channel [appendArgs \
  1752         -                      "no, failed to " [expr {$native ? "add" : "remove"}] \
  1753         -                      " the \"native\" runtime option\n"]
         1834  +                      "yes, selected (" [expr {$native ? "native/" : ""}] \
         1835  +                      [expr {[string length $platform] > 0 ? [appendArgs \
         1836  +                      $platform /] : ""}] $year / $configuration \
         1837  +                      [expr {[string length $extra] > 0 ? [appendArgs / \
         1838  +                      $extra] : ""}] ")\n"]
  1754   1839   
  1755         -                  return false
         1840  +                  return true
         1841  +                } else {
         1842  +                  tputs $channel yes\n
  1756   1843                   }
  1757         -
  1758         -                set ::test_year $year
  1759         -                set ::test_platform $platform
  1760         -                set ::test_configuration $configuration
  1761         -
  1762         -                tputs $channel [appendArgs \
  1763         -                    "yes, selected (" [expr {$native ? "native/" : ""}] \
  1764         -                    [expr {[string length $platform] > 0 ? [appendArgs \
  1765         -                    $platform /] : ""}] $year / $configuration ")\n"]
  1766         -
  1767         -                return true
  1768   1844                 } else {
  1769         -                tputs $channel yes\n
         1845  +                tputs $channel no\n
  1770   1846                 }
  1771         -            } else {
  1772         -              tputs $channel no\n
  1773   1847               }
  1774   1848             }
  1775   1849           }
  1776   1850         }
  1777   1851   
  1778   1852         return false
  1779   1853       }
................................................................................
  4384   4458           #       these files may be native and/or managed assemblies that are
  4385   4459           #       required to perform various tests.
  4386   4460           #
  4387   4461           set externalFileNames [list \
  4388   4462               [file join EntityFramework lib [string map [list Fx ""] \
  4389   4463               [string map [list netFx451 netFx45 netFx452 netFx45 netFx46 \
  4390   4464               netFx45 netFx461 netFx45 netFx462 netFx45 netFx47 netFx45 \
  4391         -            netFx471 netFx45] [getBuildNetFx]]] EntityFramework.dll]]
         4465  +            netFx471 netFx45 netStandard20 netFx45] [getBuildNetFx]]] \
         4466  +            EntityFramework.dll]]
  4392   4467   
  4393   4468           #
  4394   4469           # NOTE: Build the list of native assembly files that we handle.
  4395   4470           #
  4396   4471           set nativeFileNames [list]
  4397   4472   
  4398   4473           eval lappend nativeFileNames [getNativeLibraryFileNamesOnly]
................................................................................
  4573   4648             #
  4574   4649             # NOTE: Skip trying to verify the build directory if instructed;
  4575   4650             #       otherwise, make sure it actually exists or halt the entire
  4576   4651             #       testing process if it does not exist.
  4577   4652             #
  4578   4653             if {![info exists ::no(verifyBuildDirectory)]} then {
  4579   4654               #
  4580         -            # NOTE: At this point, the build directory MUST exist as a
  4581         -            #       valid directory for the testing process to continue.
         4655  +            # NOTE: At this point, the build directories MUST exist for
         4656  +            #       the testing process to continue.
  4582   4657               #
  4583   4658               set directory [getBuildDirectory false]
  4584   4659   
  4585   4660               if {![file exists $directory] || \
  4586   4661                   ![file isdirectory $directory]} then {
  4587   4662                 #
  4588   4663                 # NOTE: Just prior to actually halting the testing process,
  4589   4664                 #       add an error to the test log file.
  4590   4665                 #
  4591   4666                 tputs $::test_channel [appendArgs \
  4592         -                  "---- could not verify build directory \"" $directory \
  4593         -                  "\", all testing halted\n"]
         4667  +                  "---- could not verify native build directory \"" \
         4668  +                  $directory "\", all testing halted\n"]
         4669  +
         4670  +              #
         4671  +              # NOTE: Raising a script error from this point should halt
         4672  +              #       the testing process.
         4673  +              #
         4674  +              error [appendArgs \
         4675  +                  "could not verify native build directory \"" \
         4676  +                  $directory "\", all testing halted"]
         4677  +            }
         4678  +
         4679  +            set directory [getBuildDirectory true]
         4680  +
         4681  +            if {![file exists $directory] || \
         4682  +                ![file isdirectory $directory]} then {
         4683  +              #
         4684  +              # NOTE: Just prior to actually halting the testing process,
         4685  +              #       add an error to the test log file.
         4686  +              #
         4687  +              tputs $::test_channel [appendArgs \
         4688  +                  "---- could not verify managed build directory \"" \
         4689  +                  $directory "\", all testing halted\n"]
  4594   4690   
  4595   4691                 #
  4596   4692                 # NOTE: Raising a script error from this point should halt
  4597   4693                 #       the testing process.
  4598   4694                 #
  4599   4695                 error [appendArgs \
  4600         -                  "could not verify build directory \"" $directory \
  4601         -                  "\", all testing halted"]
         4696  +                  "could not verify managed build directory \"" \
         4697  +                  $directory "\", all testing halted"]
  4602   4698               }
  4603   4699             }
  4604   4700   
  4605   4701             #
  4606   4702             # NOTE: Skip trying to copy any files if instructed.
  4607   4703             #
  4608   4704             if {![info exists ::no(copySqliteFiles)]} then {
................................................................................
  4764   4860               }
  4765   4861             }
  4766   4862           }
  4767   4863   
  4768   4864           foreach fileNameOnly $nativeFileNames {
  4769   4865             catch {
  4770   4866               tputs $::test_channel [appendArgs \
  4771         -                "---- file version of \"" $fileNameOnly "\"... \"" \
  4772         -                [file version [getBinaryFileName $fileNameOnly]] \"\n]
         4867  +                "---- file version of \"" native/ $fileNameOnly \
         4868  +                "\"... \"" [file version [getBinaryFileName \
         4869  +                $fileNameOnly]] \"\n]
  4773   4870             }
  4774   4871           }
  4775   4872   
  4776   4873           foreach fileNameOnly $mixedFileNames {
  4777   4874             catch {
  4778   4875               tputs $::test_channel [appendArgs \
  4779         -                "---- file version of \"" $fileNameOnly "\"... \"" \
  4780         -                [file version [getBinaryFileName $fileNameOnly]] \"\n]
         4876  +                "---- file version of \"" mixed/ $fileNameOnly \
         4877  +                "\"... \"" [file version [getBinaryFileName \
         4878  +                $fileNameOnly]] \"\n]
  4781   4879             }
  4782   4880           }
  4783   4881   
  4784   4882           foreach fileNameOnly $managedFileNames {
  4785   4883             catch {
  4786   4884               tputs $::test_channel [appendArgs \
  4787         -                "---- file version of \"" $fileNameOnly "\"... \"" \
  4788         -                [file version [getBinaryFileName $fileNameOnly]] \"\n]
         4885  +                "---- file version of \"" managed/ $fileNameOnly \
         4886  +                "\"... \"" [file version [getBinaryFileName \
         4887  +                $fileNameOnly]] \"\n]
  4789   4888             }
  4790   4889           }
  4791   4890   
  4792   4891           if {[string length $platform] > 0} then {
  4793   4892             foreach fileNameOnly $nativeFileNames {
  4794   4893               catch {
  4795   4894                 tputs $::test_channel [appendArgs \
  4796         -                  "---- file version of \"" $platform \
  4797         -                  / $fileNameOnly "\"... \"" [file version \
  4798         -                  [getBinaryFileName $fileNameOnly $platform]] \"\n]
         4895  +                  "---- file version of \"" native/platform/ \
         4896  +                  $platform / $fileNameOnly "\"... \"" [file \
         4897  +                  version [getBinaryFileName $fileNameOnly \
         4898  +                  $platform]] \"\n]
  4799   4899               }
  4800   4900             }
  4801   4901   
  4802   4902             foreach fileNameOnly $mixedFileNames {
  4803   4903               catch {
  4804   4904                 tputs $::test_channel [appendArgs \
  4805         -                  "---- file version of \"" $platform \
  4806         -                  / $fileNameOnly "\"... \"" [file version \
  4807         -                  [getBinaryFileName $fileNameOnly $platform]] \"\n]
         4905  +                  "---- file version of \"" mixed/platform/ \
         4906  +                  $platform / $fileNameOnly "\"... \"" [file \
         4907  +                  version [getBinaryFileName $fileNameOnly \
         4908  +                  $platform]] \"\n]
  4808   4909               }
  4809   4910             }
  4810   4911           }
  4811   4912   
  4812   4913           if {[string length $architecture] > 0} then {
  4813   4914             foreach fileNameOnly $nativeFileNames {
  4814   4915               catch {
  4815   4916                 tputs $::test_channel [appendArgs \
  4816         -                  "---- file version of \"" $architecture \
  4817         -                  / $fileNameOnly "\"... \"" [file version \
  4818         -                  [getBinaryFileName $fileNameOnly $architecture]] \"\n]
         4917  +                  "---- file version of \"" native/architecture/ \
         4918  +                  $architecture / $fileNameOnly "\"... \"" [file \
         4919  +                  version [getBinaryFileName $fileNameOnly \
         4920  +                  $architecture]] \"\n]
  4819   4921               }
  4820   4922             }
  4821   4923   
  4822   4924             foreach fileNameOnly $mixedFileNames {
  4823   4925               catch {
  4824   4926                 tputs $::test_channel [appendArgs \
  4825         -                  "---- file version of \"" $architecture \
  4826         -                  / $fileNameOnly "\"... \"" [file version \
  4827         -                  [getBinaryFileName $fileNameOnly $architecture]] \"\n]
         4927  +                  "---- file version of \"" mixed/architecture/ \
         4928  +                  $architecture / $fileNameOnly "\"... \"" [file \
         4929  +                  version [getBinaryFileName $fileNameOnly \
         4930  +                  $architecture]] \"\n]
  4828   4931               }
  4829   4932             }
  4830   4933           }
  4831   4934   
  4832   4935           #
  4833   4936           # NOTE: Grab the list of managed assemblies for the current process
  4834   4937           #       and report on the System.Data.SQLite related ones.
................................................................................
  5024   5127           tputs $::test_channel \
  5025   5128               "---- checking for System.Data.SQLite build year... "
  5026   5129   
  5027   5130           set year [getBuildYear]
  5028   5131           addConstraint [appendArgs buildYear. $year]
  5029   5132           tputs $::test_channel [appendArgs \" $year \"\n]
  5030   5133   
         5134  +        tputs $::test_channel \
         5135  +            "---- checking for System.Data.SQLite build native year... "
         5136  +
         5137  +        set year [getBuildNativeYear]
         5138  +        addConstraint [appendArgs buildNativeYear. $year]
         5139  +        tputs $::test_channel [appendArgs \" $year \"\n]
         5140  +
  5031   5141           #
  5032   5142           # NOTE: Check the current build .NET Framework.  Basically, this
  5033   5143           #       indicates which version of the .NET Framework is being
  5034   5144           #       used by the assembly binaries under test.
  5035   5145           #
  5036   5146           tputs $::test_channel \
  5037   5147               "---- checking for System.Data.SQLite build .NET Framework... "
................................................................................
  5046   5156           #
  5047   5157           tputs $::test_channel \
  5048   5158               "---- checking for System.Data.SQLite build configuration... "
  5049   5159   
  5050   5160           set configuration [getBuildConfiguration]
  5051   5161           addConstraint [appendArgs buildConfiguration. $configuration]
  5052   5162           tputs $::test_channel [appendArgs \" $configuration \"\n]
         5163  +
         5164  +        tputs $::test_channel \
         5165  +            "---- checking for System.Data.SQLite build extra... "
         5166  +
         5167  +        #
         5168  +        # NOTE: Check the current build extra directory.  This will normally
         5169  +        #       be either "netstandard2.0" or an empty string.
         5170  +        #
         5171  +        set extra [getBuildExtra]
         5172  +
         5173  +        if {[string length $extra] > 0} then {
         5174  +          addConstraint [appendArgs buildExtra. $extra]
         5175  +          tputs $::test_channel [appendArgs \" $extra \"\n]
         5176  +        } else {
         5177  +          addConstraint buildExtra.none
         5178  +          tputs $::test_channel <none>\n
         5179  +        }
  5053   5180   
  5054   5181           #
  5055   5182           # NOTE: Try to setup an interrupt callback using the script debugger
  5056   5183           #       that will cancel all SQL queries in progress for all database
  5057   5184           #       connections known to this interpreter.
  5058   5185           #
  5059   5186           if {![info exists ::no(sqliteInterruptCallback)]} then {

Changes to readme.htm.

   209    209   
   210    210   <p>
   211    211       <b>1.0.109.0 - May XX, 2018 <font color="red">(release scheduled)</font></b>
   212    212   </p>
   213    213   <ul>
   214    214       <li>Updated to <a href="https://www.sqlite.org/releaselog/3_23_1.html">SQLite 3.23.1</a>.</li>
   215    215       <li>Prevent GetSchemaTable from throwing InvalidCastException. Fix for [baf42ee135].</li>
          216  +    <li>Add preliminary support for .NET Core 2.0 and the .NET Standard 2.0.</li>
   216    217       <li>Add simpler overload for the SQLiteBlob.Create method. Pursuant to [dfc8133ba2].</li>
   217    218       <li>Add GetFieldAffinity method to the SQLiteDataReader class.</li>
   218    219   </ul>
   219    220   <p>
   220    221       <b>1.0.XXX.0 - March 2, 2018</b>
   221    222   </p>
   222    223   <ul>

Changes to www/build.wiki.

   419    419         <b>build_mono.bat</b>
   420    420         <br />
   421    421         <br />
   422    422       </li>
   423    423   
   424    424       <li>
   425    425         Make sure everything succeeds with no errors; the log file
   426         -      &quot;%TEMP%\System.Data.SQLite.Build_ReleaseManagedOnly_Win32_&lt;year&gt;_Unknown.log&quot;
          426  +      &quot;%TEMP%\System.Data.SQLite.Build_ReleaseManagedOnly_Any CPU_&lt;year&gt;_Unknown.log&quot;
          427  +      may be checked if any errors should occur.
          428  +    </li>
          429  +  </ol>
          430  +
          431  +  <a name="netStandard20"></a>
          432  +  <h2>.NET Standard 2.0 Build</h2>
          433  +
          434  +  <ol>
          435  +    <li>
          436  +      Complete the applicable steps outlined in the <a href="#all">All Builds</a>
          437  +      section (above).
          438  +    </li>
          439  +
          440  +    <li>
          441  +      Make sure the &quot;&lt;root&gt;\bin&quot; and &quot;&lt;root&gt;\obj&quot;
          442  +      directories are completely free of all output files.  In theory, you should
          443  +      be able to simply delete these directories.
          444  +    </li>
          445  +
          446  +    <li>Open a normal command prompt window with &quot;cmd.exe&quot;.</li>
          447  +
          448  +    <li>Change the current directory to &quot;&lt;root&gt;\Setup&quot;.</li>
          449  +
          450  +    <li>
          451  +      Enter the following command to build the managed-only binaries for .NET
          452  +      Standard 2.0:
          453  +      <br />
          454  +      <br />
          455  +      <b>build_net_standard_20.bat</b>
          456  +      <br />
          457  +      <br />
          458  +    </li>
          459  +
          460  +    <li>
          461  +      Make sure everything succeeds with no errors; the log file
          462  +      &quot;%TEMP%\System.Data.SQLite.Build_ReleaseManagedOnly_Any CPU_NetStandard20_Unknown.log&quot;
   427    463         may be checked if any errors should occur.
   428    464       </li>
   429    465     </ol>
   430    466   </nowiki>

Changes to www/downloads.wiki.

  2524   2524       The <b>platform</b> in templates (7), (8), (9), and (10) will be one of
  2525   2525       Win32, x64, PocketPC, PocketPC-ARM, PocketPC-x86, WinCE-ARM, WinCE-x86,
  2526   2526       Mono.
  2527   2527     </p>
  2528   2528   
  2529   2529     <p>
  2530   2530       The <b>year</b> in templates (5), (6), (7), (8), (9), and (10) will be
  2531         -    one of 2005, 2008, 2010, 2012, 2013, 2015, 2017, 20XX.
         2531  +    one of 2005, 2008, 2010, 2012, 2013, 2015, 2017, 20XX, NetStandard20.
  2532   2532     </p>
  2533   2533   
  2534   2534     <p>
  2535   2535       The <b>version</b> in templates (1), (2), (3), (4), (5), (6), (7), (8),
  2536   2536       (9), (10), (13), (14), and (15) is the dot-delimited version number of
  2537   2537       the primary System.Data.SQLite assembly.
  2538   2538     </p>

Changes to www/news.wiki.

    46     46   
    47     47   <p>
    48     48       <b>1.0.109.0 - May XX, 2018 <font color="red">(release scheduled)</font></b>
    49     49   </p>
    50     50   <ul>
    51     51       <li>Updated to [https://www.sqlite.org/releaselog/3_23_1.html|SQLite 3.23.1].</li>
    52     52       <li>Prevent GetSchemaTable from throwing InvalidCastException. Fix for [baf42ee135].</li>
           53  +    <li>Add preliminary support for .NET Core 2.0 and the .NET Standard 2.0.</li>
    53     54       <li>Add simpler overload for the SQLiteBlob.Create method. Pursuant to [dfc8133ba2].</li>
    54     55       <li>Add GetFieldAffinity method to the SQLiteDataReader class.</li>
    55     56   </ul>
    56     57   <p>
    57     58       <b>1.0.108.0 - March 2, 2018</b>
    58     59   </p>
    59     60   <ul>

Changes to www/release.wiki.

   229    229     </li>
   230    230   
   231    231     <li>
   232    232       Make sure everything succeeds with no errors; the console output may be
   233    233       checked if any errors should occur.
   234    234     </li>
   235    235   </ol>
          236  +
          237  +<a name="buildNetStandard20Binaries"></a>
          238  +<h2>Build .NET Standard 2.0 Binaries</h2>
          239  +
          240  +<ol>
          241  +  <li>Open a normal command prompt window with &quot;cmd.exe&quot;.</li>
          242  +
          243  +  <li>Change the current directory to &quot;&lt;root&gt;\Setup&quot;.</li>
          244  +
          245  +  <li>
          246  +    Enter the following command to build all the binaries available for .NET
          247  +    Standard 2.0:
          248  +    <br />
          249  +    <br />
          250  +    <b>SET BUILD_FULL=</b>
          251  +    <br />
          252  +    <b>SET BUILD_DEBUG=1</b>
          253  +    <br />
          254  +    <b>build_net_standard_20.bat</b>
          255  +  </li>
          256  +
          257  +  <li>
          258  +    Make sure everything succeeds with no errors; the console output may be
          259  +    checked if any errors should occur.
          260  +  </li>
          261  +</ol>
   236    262   
   237    263   <a name="updateDocumentation"></a>
   238    264   <h2>Update Documentation</h2>
   239    265   
   240    266   <ol>
   241    267     <li>
   242    268       Update the &quot;&lt;root&gt;\readme.htm&quot; file with information about
................................................................................
   253    279     <li>Change the current directory to &quot;&lt;root&gt;\Doc&quot;.</li>
   254    280   
   255    281     <li>
   256    282       Enter the following command to update all documentation that is
   257    283       included from upstream (e.g. from the SQLite core library, etc):
   258    284       <br />
   259    285       <br />
   260         -    <b>..\Externals\Eagle\bin\EagleShell.exe -file sync.eagle --verbose</b>
          286  +    <b>..\Externals\Eagle\bin\netFramework40\EagleShell.exe -file sync.eagle --verbose</b>
   261    287     </li>
   262    288   
   263    289     <li>
   264    290       Enter the following command to update the embedded SQLite core library
   265    291       virtual table documentation:
   266    292       <br />
   267    293       <br />
................................................................................
   431    457     </li>
   432    458   
   433    459     <li>
   434    460       Make sure everything succeeds with no errors; the console output may be
   435    461       checked if any errors should occur.
   436    462     </li>
   437    463   </ol>
          464  +
          465  +<a name="buildNetStandard20BinaryPackages"></a>
          466  +<h2>Build .NET Standard 2.0 Release Packages</h2>
          467  +
          468  +<ol>
          469  +  <li>Open a normal command prompt window with &quot;cmd.exe&quot;.</li>
          470  +
          471  +  <li>Change the current directory to &quot;&lt;root&gt;\Setup&quot;.</li>
          472  +
          473  +  <li>
          474  +    Enter the following commands to build all the Mono release packages:
          475  +    <br />
          476  +    <br />
          477  +    <b>SET RELEASE_DEBUG=1</b>
          478  +    <br />
          479  +    <b>release_net_standard_20.bat</b>
          480  +  </li>
          481  +
          482  +  <li>
          483  +    Make sure everything succeeds with no errors; the console output may be
          484  +    checked if any errors should occur.
          485  +  </li>
          486  +</ol>
   438    487   
   439    488   <a name="buildSourcePackages"></a>
   440    489   <h2>Build Source Release Packages</h2>
   441    490   
   442    491   <ol>
   443    492     <li>Open a normal command prompt window with &quot;cmd.exe&quot;.</li>
   444    493   
................................................................................
   504    553   
   505    554     <li>Change the current directory to &quot;&lt;root&gt;\Setup&quot;.</li>
   506    555   
   507    556     <li>
   508    557       Enter the following command to build all the source release packages:
   509    558       <br />
   510    559       <br />
   511         -    <b>..\Externals\Eagle\bin\EagleShell.exe -file verify.eagle Output true</b>
          560  +    <b>..\Externals\Eagle\bin\netFramework40\EagleShell.exe -file verify.eagle Output true</b>
   512    561       <br />
   513    562       <br />
   514    563       <i>This assumes that the <a href="https://www.fossil-scm.org/">Fossil</a>,
   515    564       <a href="https://sourceforge.net/projects/innounp/">Inno Setup Unpacker</a>,
   516    565       <a href="http://www.rarlab.com/">UnRAR</a>, and
   517    566       <a href="http://www.info-zip.org/">UnZip</a> binaries are available in the
   518    567       locations specified via the &quot;FossilTool&quot;,

Changes to www/test.wiki.

    80     80     <li>Change the current directory to &quot;&lt;root&gt;&quot;.</li>
    81     81   
    82     82     <li>
    83     83       Enter the following command to run all the unit tests against the binaries
    84     84       built with a separate managed and interop assembly:
    85     85       <br />
    86     86       <br />
    87         -    <b>Externals\Eagle\bin\EagleShell.exe&nbsp;-file&nbsp;Tests\all.eagle</b>
           87  +    <b>Externals\Eagle\bin\netFramework40\EagleShell.exe&nbsp;-file&nbsp;Tests\all.eagle</b>
    88     88     </li>
    89     89   
    90     90     <li>
    91     91       Enter the following command to run all the unit tests against the binaries
    92     92       built with a mixed-mode assembly:
    93     93       <br />
    94     94       <br />
    95         -    <b>Externals\Eagle\bin\EagleShell.exe&nbsp;-initialize&nbsp;-runtimeOption&nbsp;native&nbsp;-file&nbsp;Tests\all.eagle</b>
           95  +    <b>Externals\Eagle\bin\netFramework40\EagleShell.exe&nbsp;-initialize&nbsp;-runtimeOption&nbsp;native&nbsp;-file&nbsp;Tests\all.eagle</b>
    96     96     </li>
    97     97   
    98     98     <li>
    99     99       In order to test binaries built with MSBuild 3.5 or Visual Studio 2008 (i.e.
   100    100       because the default is to test binaries built with MSBuild 4.0 or Visual
   101    101       Studio 2010) add the following command line argument right after
   102         -    &quot;<b>Externals\Eagle\bin\EagleShell.exe</b>&quot; in any of the above
   103         -    command lines:
          102  +    &quot;<b>Externals\Eagle\bin\netFramework40\EagleShell.exe</b>&quot; in any
          103  +    of the above command lines:
   104    104       <br />
   105    105       <br />
   106    106       <b>-anyInitialize&nbsp;&quot;set&nbsp;test_year&nbsp;2008&quot;</b>
   107    107     </li>
   108    108   
   109    109     <li>
   110    110       In order to test binaries built in the &quot;Debug&quot; build configuration
   111    111       (i.e. because the default is to test binaries built in the
   112    112       &quot;Release&quot; build configuration) add the following command line
   113         -    argument right after &quot;<b>Externals\Eagle\bin\EagleShell.exe</b>&quot;
   114         -    in any of the above command lines:
          113  +    argument right after
          114  +    &quot;<b>Externals\Eagle\bin\netFramework40\EagleShell.exe</b>&quot; in any
          115  +    of the above command lines:
   115    116       <br />
   116    117       <br />
   117    118       <b>-anyInitialize&nbsp;&quot;set&nbsp;test_configuration&nbsp;Debug&quot;</b>
   118    119     </li>
   119    120   
   120    121     <li>
   121    122       In order to test the native library pre-loader, add the following command
   122    123       line argument right after
   123         -    &quot;<b>Externals\Eagle\bin\EagleShell.exe</b>&quot;
          124  +    &quot;<b>Externals\Eagle\bin\netFramework40\EagleShell.exe</b>&quot;
   124    125       in any of the above command lines:
   125    126       <br />
   126    127       <br />
   127    128       <b>-anyInitialize&nbsp;&quot;set&nbsp;no(copySqliteImplicitFiles)&nbsp;1&quot;</b>
   128    129     </li>
   129    130   
   130    131     <li>