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

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

Overview
Comment:Update the Eagle script library in externals to the latest trunk, needed for its test suite infrastructure updates for Visual Studio 2013 and the .NET Framework 4.5.1.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | vs2013
Files: files | file ages | folders
SHA1: d0704d07a1167248aeaf062e411b719a701783b5
User & Date: mistachkin 2013-11-27 04:49:27
Context
2013-11-27
04:57
Update SQLite core library to the latest trunk code. check-in: d77d930e0d user: mistachkin tags: vs2013
04:49
Update the Eagle script library in externals to the latest trunk, needed for its test suite infrastructure updates for Visual Studio 2013 and the .NET Framework 4.5.1. check-in: d0704d07a1 user: mistachkin tags: vs2013
02:15
Take into account the additional math functions available with MSVC 2013. check-in: 07ecc4ebfa user: mistachkin tags: vs2013
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

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

    47     47   
    48     48       #
    49     49       # NOTE: Is the Eagle Package for Tcl (Garuda) available?  This check
    50     50       #       is different in Eagle and Tcl.
    51     51       #
    52     52       if {[isEagle]} then {
    53     53         return [expr {[llength [info commands tcl]] > 0 && [tcl ready] && \
    54         -          [catch {tcl eval [tcl master] package present Garuda}] == 0 && \
    55         -          [catch {tcl eval [tcl master] garuda packageid} packageId] == 0}]
           54  +          [catch {tcl eval [tcl master] {package present Garuda}}] == 0 && \
           55  +          [catch {tcl eval [tcl master] {garuda packageid}} packageId] == 0}]
    56     56       } else {
    57     57         return [expr {[catch {package present Garuda}] == 0 && \
    58     58             [catch {garuda packageid} packageId] == 0}]
    59     59       }
    60     60     }
    61     61   
    62     62     proc isTclThread { name } {
................................................................................
   296    296       return ""
   297    297     }
   298    298   
   299    299     proc readFile { fileName } {
   300    300       #
   301    301       # NOTE: This should work properly in both Tcl and Eagle.
   302    302       #
   303         -    set file_id [open $fileName RDONLY]
   304         -    fconfigure $file_id -encoding binary -translation binary; # BINARY DATA
   305         -    set result [read $file_id]
   306         -    close $file_id
          303  +    set channel [open $fileName RDONLY]
          304  +    fconfigure $channel -encoding binary -translation binary; # BINARY DATA
          305  +    set result [read $channel]
          306  +    close $channel
   307    307       return $result
   308    308     }
   309    309   
   310    310     proc readSharedFile { fileName } {
   311    311       #
   312    312       # NOTE: This should work properly in both Tcl and Eagle.
   313    313       #
................................................................................
   322    322         lappend command 0 file -share readWrite
   323    323       }
   324    324   
   325    325       #
   326    326       # NOTE: Open the file using the command constructed above, configure
   327    327       #       the channel for binary data, and output the data to it.
   328    328       #
   329         -    set file_id [eval $command]
   330         -    fconfigure $file_id -encoding binary -translation binary; # BINARY DATA
   331         -    set result [read $file_id]
   332         -    close $file_id
          329  +    set channel [eval $command]
          330  +    fconfigure $channel -encoding binary -translation binary; # BINARY DATA
          331  +    set result [read $channel]
          332  +    close $channel
   333    333       return $result
   334    334     }
   335    335   
   336    336     proc writeFile { fileName data } {
   337    337       #
   338    338       # NOTE: This should work properly in both Tcl and Eagle.
   339    339       #
   340         -    set file_id [open $fileName {WRONLY CREAT TRUNC}]
   341         -    fconfigure $file_id -encoding binary -translation binary; # BINARY DATA
   342         -    puts -nonewline $file_id $data
   343         -    close $file_id
          340  +    set channel [open $fileName {WRONLY CREAT TRUNC}]
          341  +    fconfigure $channel -encoding binary -translation binary; # BINARY DATA
          342  +    puts -nonewline $channel $data
          343  +    close $channel
   344    344       return ""
   345    345     }
   346    346   
   347    347     proc appendFile { fileName data } {
   348    348       #
   349    349       # NOTE: This should work properly in both Tcl and Eagle.
   350    350       #
   351         -    set file_id [open $fileName {WRONLY CREAT APPEND}]
   352         -    fconfigure $file_id -encoding binary -translation binary; # BINARY DATA
   353         -    puts -nonewline $file_id $data
   354         -    close $file_id
          351  +    set channel [open $fileName {WRONLY CREAT APPEND}]
          352  +    fconfigure $channel -encoding binary -translation binary; # BINARY DATA
          353  +    puts -nonewline $channel $data
          354  +    close $channel
   355    355       return ""
   356    356     }
   357    357   
   358    358     proc appendLogFile { fileName data } {
   359    359       #
   360    360       # NOTE: This should work properly in both Tcl and Eagle.
   361    361       #
   362         -    set file_id [open $fileName {WRONLY CREAT APPEND}]
   363         -    fconfigure $file_id -encoding binary -translation \
          362  +    set channel [open $fileName {WRONLY CREAT APPEND}]
          363  +    fconfigure $channel -encoding binary -translation \
   364    364           [expr {[isEagle] ? "protocol" : "auto"}]; # LOG DATA
   365         -    puts -nonewline $file_id $data
   366         -    close $file_id
          365  +    puts -nonewline $channel $data
          366  +    close $channel
   367    367       return ""
   368    368     }
   369    369   
   370    370     proc appendSharedFile { fileName data } {
   371    371       #
   372    372       # NOTE: This should work properly in both Tcl and Eagle.
   373    373       #
................................................................................
   382    382         lappend command 0 file -share readWrite
   383    383       }
   384    384   
   385    385       #
   386    386       # NOTE: Open the file using the command constructed above, configure
   387    387       #       the channel for binary data, and output the data to it.
   388    388       #
   389         -    set file_id [eval $command]
   390         -    fconfigure $file_id -encoding binary -translation binary; # BINARY DATA
   391         -    puts -nonewline $file_id $data; flush $file_id
   392         -    close $file_id
          389  +    set channel [eval $command]
          390  +    fconfigure $channel -encoding binary -translation binary; # BINARY DATA
          391  +    puts -nonewline $channel $data; flush $channel
          392  +    close $channel
   393    393       return ""
   394    394     }
   395    395   
   396    396     proc appendSharedLogFile { fileName data } {
   397    397       #
   398    398       # NOTE: This should work properly in both Tcl and Eagle.
   399    399       #
................................................................................
   408    408         lappend command 0 file -share readWrite
   409    409       }
   410    410   
   411    411       #
   412    412       # NOTE: Open the file using the command constructed above, configure
   413    413       #       the channel for binary data, and output the data to it.
   414    414       #
   415         -    set file_id [eval $command]
   416         -    fconfigure $file_id -encoding binary -translation \
          415  +    set channel [eval $command]
          416  +    fconfigure $channel -encoding binary -translation \
   417    417           [expr {[isEagle] ? "protocol" : "auto"}]; # LOG DATA
   418         -    puts -nonewline $file_id $data; flush $file_id
   419         -    close $file_id
          418  +    puts -nonewline $channel $data; flush $channel
          419  +    close $channel
   420    420       return ""
   421    421     }
   422    422   
   423    423     proc readAsciiFile { fileName } {
   424    424       #
   425    425       # NOTE: This should work properly in both Tcl and Eagle.
   426    426       #
   427         -    set file_id [open $fileName RDONLY]
   428         -    fconfigure $file_id -encoding ascii -translation auto; # ASCII TEXT
   429         -    set result [read $file_id]
   430         -    close $file_id
          427  +    set channel [open $fileName RDONLY]
          428  +    fconfigure $channel -encoding ascii -translation auto; # ASCII TEXT
          429  +    set result [read $channel]
          430  +    close $channel
   431    431       return $result
   432    432     }
   433    433   
   434    434     proc writeAsciiFile { fileName data } {
   435    435       #
   436    436       # NOTE: This should work properly in both Tcl and Eagle.
   437    437       #
   438         -    set file_id [open $fileName {WRONLY CREAT TRUNC}]
   439         -    fconfigure $file_id -encoding ascii -translation auto; # ASCII TEXT
   440         -    puts -nonewline $file_id $data
   441         -    close $file_id
          438  +    set channel [open $fileName {WRONLY CREAT TRUNC}]
          439  +    fconfigure $channel -encoding ascii -translation auto; # ASCII TEXT
          440  +    puts -nonewline $channel $data
          441  +    close $channel
   442    442       return ""
   443    443     }
   444    444   
   445    445     proc readUnicodeFile { fileName } {
   446    446       #
   447    447       # NOTE: This should work properly in both Tcl and Eagle.
   448    448       #
   449         -    set file_id [open $fileName RDONLY]
   450         -    fconfigure $file_id -encoding unicode -translation auto; # UNICODE TEXT
   451         -    set result [read $file_id]
   452         -    close $file_id
          449  +    set channel [open $fileName RDONLY]
          450  +    fconfigure $channel -encoding unicode -translation auto; # UNICODE TEXT
          451  +    set result [read $channel]
          452  +    close $channel
   453    453       return $result
   454    454     }
   455    455   
   456    456     proc writeUnicodeFile { fileName data } {
   457    457       #
   458    458       # NOTE: This should work properly in both Tcl and Eagle.
   459    459       #
   460         -    set file_id [open $fileName {WRONLY CREAT TRUNC}]
   461         -    fconfigure $file_id -encoding unicode -translation auto; # UNICODE TEXT
   462         -    puts -nonewline $file_id $data
   463         -    close $file_id
          460  +    set channel [open $fileName {WRONLY CREAT TRUNC}]
          461  +    fconfigure $channel -encoding unicode -translation auto; # UNICODE TEXT
          462  +    puts -nonewline $channel $data
          463  +    close $channel
   464    464       return ""
   465    465     }
   466    466   
   467    467     proc getDirResultPath { pattern path } {
   468    468       #
   469    469       # NOTE: This should work properly in both Tcl and Eagle.
   470    470       #       Is the result path itself already absolute?
................................................................................
  1158   1158           return "cannot fetch update, the URI is invalid"
  1159   1159         }
  1160   1160       }
  1161   1161   
  1162   1162       proc runUpdateAndExit {} {
  1163   1163         set directory [file dirname [info nameofexecutable]]
  1164   1164   
  1165         -      set command [list exec -- \
         1165  +      set command [list exec -shell -- \
  1166   1166             [file join $directory Hippogriff.exe] -delay 2000]
  1167   1167   
  1168   1168         eval $command &; exit -force
  1169   1169       }
  1170   1170   
  1171   1171       proc getUpdateData { uri } {
  1172   1172         #
................................................................................
  1212   1212   
  1213   1213       #
  1214   1214       # NOTE: This proc is used to check for new versions -OR- new update
  1215   1215       #       scripts for the runtime when a user executes the interactive
  1216   1216       #       "#check" command.  To disable this functionality, simply
  1217   1217       #       redefine this procedure to do nothing.
  1218   1218       #
  1219         -    proc checkForUpdate { {wantScripts false} } {
         1219  +    proc checkForUpdate { {wantScripts false} {quiet false} } {
  1220   1220         #
  1221   1221         # NOTE: This should work properly in Eagle only.
  1222   1222         #
  1223   1223         set updateUri [appendArgs [info engine Uri] [info engine UpdateFile]]
  1224   1224   
  1225   1225         #
  1226   1226         # NOTE: Fetch the master update data from the distribution site
................................................................................
  1232   1232         # NOTE: Split the data into lines.
  1233   1233         #
  1234   1234         set lines [split $updateData \n]
  1235   1235   
  1236   1236         #
  1237   1237         # NOTE: Keep track of how many update scripts are processed.
  1238   1238         #
  1239         -      set scriptCount 0
         1239  +      array set scriptCount {
         1240  +        invalid            0 fail               0 bad                0
         1241  +        ok                 0 error              0
         1242  +      }
  1240   1243   
  1241   1244         #
  1242   1245         # NOTE: Check each line to find the build information...
  1243   1246         #
  1244   1247         foreach line $lines {
  1245   1248           #
  1246   1249           # NOTE: Remove excess whitespace.
................................................................................
  1315   1318                 #
  1316   1319                 set patchLevel [lindex $fields 4]
  1317   1320   
  1318   1321                 if {[string length $patchLevel] == 0} then {
  1319   1322                   set patchLevel 0.0.0.0; # no patch level?
  1320   1323                 }
  1321   1324   
         1325  +              #
         1326  +              # NOTE: Grab the time-stamp field.
         1327  +              #
         1328  +              set timeStamp [lindex $fields 5]
         1329  +
         1330  +              if {[string length $timeStamp] == 0} then {
         1331  +                set timeStamp 0; #never?
         1332  +              }
         1333  +
         1334  +              #
         1335  +              # NOTE: Does it look like the number of seconds since the epoch
         1336  +              #       or some kind of date/time string?
         1337  +              #
         1338  +              if {[string is integer -strict $timeStamp]} then {
         1339  +                set dateTime [clock format $timeStamp]
         1340  +              } else {
         1341  +                set dateTime [clock format [clock scan $timeStamp]]
         1342  +              }
         1343  +
  1322   1344                 #
  1323   1345                 # NOTE: Grab the patch level for the running engine.
  1324   1346                 #
  1325   1347                 set enginePatchLevel [info engine PatchLevel]
  1326   1348   
  1327   1349                 #
  1328         -              # NOTE: Compare the patch level from the line to the one we
  1329         -              #       are currently using.
         1350  +              # NOTE: Grab the time-stamp for the running engine.
         1351  +              #
         1352  +              set engineTimeStamp [info engine TimeStamp]
         1353  +
         1354  +              if {[string length $engineTimeStamp] == 0} then {
         1355  +                set engineTimeStamp 0; #never?
         1356  +              }
         1357  +
         1358  +              #
         1359  +              # NOTE: Does it look like the number of seconds since the epoch
         1360  +              #       or some kind of date/time string?
         1361  +              #
         1362  +              if {[string is integer -strict $engineTimeStamp]} then {
         1363  +                set engineDateTime [clock format $engineTimeStamp]
         1364  +              } else {
         1365  +                set engineDateTime [clock format [clock scan $engineTimeStamp]]
         1366  +              }
         1367  +
         1368  +              #
         1369  +              # NOTE: For build lines, compare the patch level from the line
         1370  +              #       to the one we are currently using using a simple patch
         1371  +              #       level comparison.
         1372  +              #
         1373  +              if {$checkBuild} then {
         1374  +                set compare [package vcompare $patchLevel $enginePatchLevel]
         1375  +              } else {
         1376  +                #
         1377  +                # NOTE: This is not a build line, no match.
         1378  +                #
         1379  +                set compare -1
         1380  +              }
         1381  +
         1382  +              #
         1383  +              # NOTE: For script lines, use regular expression matching.
  1330   1384                 #
  1331         -              set compare [package vcompare $patchLevel $enginePatchLevel]
  1332         -
  1333         -              if {($checkBuild && $compare > 0) || \
  1334         -                  ($checkScript && $compare == 0)} then {
         1385  +              if {$checkScript} then {
  1335   1386                   #
  1336         -                # NOTE: Grab the time-stamp field.
         1387  +                # NOTE: Use [catch] here to prevent raising a script error
         1388  +                #       due to a malformed patch level regular expression.
  1337   1389                   #
  1338         -                set timeStamp [lindex $fields 5]
  1339         -
  1340         -                if {[string length $timeStamp] == 0} then {
  1341         -                  set timeStamp 0; #never?
         1390  +                if {[catch {
         1391  +                  regexp -nocase -- $patchLevel $enginePatchLevel
         1392  +                } match]} then {
         1393  +                  #
         1394  +                  # NOTE: The patch level from the script line was most
         1395  +                  #       likely not a valid regular expression.
         1396  +                  #
         1397  +                  set match false
  1342   1398                   }
         1399  +              } else {
         1400  +                #
         1401  +                # NOTE: This is not a script line, no match.
         1402  +                #
         1403  +                set match false
         1404  +              }
  1343   1405   
         1406  +              #
         1407  +              # NOTE: Are we interested in further processing this line?
         1408  +              #
         1409  +              if {($checkBuild && $compare > 0) ||
         1410  +                  ($checkScript && $match)} then {
  1344   1411                   #
  1345   1412                   # NOTE: Grab the base URI field (i.e. it may be a mirror
  1346   1413                   #       site).
  1347   1414                   #
  1348   1415                   set baseUri [lindex $fields 6]
  1349   1416   
  1350   1417                   if {$checkBuild && [string length $baseUri] == 0} then {
................................................................................
  1356   1423                   #
  1357   1424                   set notes [lindex $fields 10]
  1358   1425   
  1359   1426                   if {[string length $notes] > 0} then {
  1360   1427                     set notes [unescapeUpdateNotes $notes]
  1361   1428                   }
  1362   1429   
  1363         -                #
  1364         -                # NOTE: Does it look like the number of seconds since the
  1365         -                #       epoch or some kind of date/time string?
  1366         -                #
  1367         -                if {[string is integer -strict $timeStamp]} then {
  1368         -                  set dateTime [clock format $timeStamp]
  1369         -                } else {
  1370         -                  set dateTime [clock format [clock scan $timeStamp]]
  1371         -                }
  1372         -
  1373   1430                   #
  1374   1431                   # NOTE: The engine patch level from the line is greater,
  1375   1432                   #       we are out-of-date.  Return the result of our
  1376   1433                   #       checking now.
  1377   1434                   #
  1378   1435                   if {$checkBuild} then {
  1379         -                  return [list [appendArgs "newer build " $patchLevel \
  1380         -                      " is available as of " $dateTime] [list $baseUri \
         1436  +                  return [list [appendArgs \
         1437  +                      "latest build " $patchLevel ", dated " $dateTime \
         1438  +                      ", is newer than running build " $enginePatchLevel \
         1439  +                      ", dated " $engineDateTime] [list $baseUri \
  1381   1440                         $patchLevel] [list $notes]]
  1382   1441                   }
  1383   1442   
  1384   1443                   #
  1385   1444                   # NOTE: The script patch level from the line matches the
  1386   1445                   #       current engine patch level exactly, this script
  1387   1446                   #       should be evaluated if it can be authenticated.
................................................................................
  1400   1459   
  1401   1460                     #
  1402   1461                     # NOTE: Next, verify the script has a valid base URI.
  1403   1462                     #       For update scripts, this must be the location
  1404   1463                     #       where the update script data can be downloaded.
  1405   1464                     #
  1406   1465                     if {[string length $baseUri] == 0} then {
  1407         -                    tqputs $channel [appendArgs \
  1408         -                        "---- invalid baseUri value for update script line: " \
  1409         -                        $line \"\n]
  1410         -
  1411         -                    continue
         1466  +                    if {!$quiet} then {
         1467  +                      tqputs $channel [appendArgs \
         1468  +                          "---- invalid baseUri value for update script " \
         1469  +                          "line: " $line \"\n]
         1470  +                    }
         1471  +                    incr scriptCount(invalid); continue
  1412   1472                     }
  1413   1473   
  1414   1474                     #
  1415   1475                     # NOTE: Next, grab the md5 field and see if it looks valid.
  1416   1476                     #       Below, the value of this field will be compared to
  1417   1477                     #       that of the actual MD5 hash of the downloaded script
  1418   1478                     #       data.
  1419   1479                     #
  1420   1480                     set lineMd5 [lindex $fields 7]
  1421   1481   
  1422   1482                     if {[string length $lineMd5] == 0} then {
  1423         -                    tqputs $channel [appendArgs \
  1424         -                        "---- invalid md5 value for update script line: " \
  1425         -                        $line \"\n]
  1426         -
  1427         -                    continue
         1483  +                    if {!$quiet} then {
         1484  +                      tqputs $channel [appendArgs \
         1485  +                          "---- invalid md5 value for update script " \
         1486  +                          "line: " $line \"\n]
         1487  +                    }
         1488  +                    incr scriptCount(invalid); continue
  1428   1489                     }
  1429   1490   
  1430   1491                     #
  1431   1492                     # NOTE: Next, grab the sha1 field and see if it looks valid.
  1432   1493                     #       Below, the value of this field will be compared to
  1433   1494                     #       that of the actual SHA1 hash of the downloaded script
  1434   1495                     #       data.
  1435   1496                     #
  1436   1497                     set lineSha1 [lindex $fields 8]
  1437   1498   
  1438   1499                     if {[string length $lineSha1] == 0} then {
  1439         -                    tqputs $channel [appendArgs \
  1440         -                        "---- invalid sha1 value for update script line: " \
  1441         -                        $line \"\n]
  1442         -
  1443         -                    continue
         1500  +                    if {!$quiet} then {
         1501  +                      tqputs $channel [appendArgs \
         1502  +                          "---- invalid sha1 value for update script " \
         1503  +                          "line: " $line \"\n]
         1504  +                    }
         1505  +                    incr scriptCount(invalid); continue
  1444   1506                     }
  1445   1507   
  1446   1508                     #
  1447   1509                     # NOTE: Next, grab the sha512 field and see if it looks
  1448   1510                     #       valid.  Below, the value of this field will be
  1449   1511                     #       compared to that of the actual SHA512 hash of the
  1450   1512                     #       downloaded script data.
  1451   1513                     #
  1452   1514                     set lineSha512 [lindex $fields 9]
  1453   1515   
  1454   1516                     if {[string length $lineSha512] == 0} then {
  1455         -                    tqputs $channel [appendArgs \
  1456         -                        "---- invalid sha512 value for update script line: " \
  1457         -                        $line \"\n]
  1458         -
  1459         -                    continue
         1517  +                    if {!$quiet} then {
         1518  +                      tqputs $channel [appendArgs \
         1519  +                          "---- invalid sha512 value for update script " \
         1520  +                          "line: " $line \"\n]
         1521  +                    }
         1522  +                    incr scriptCount(invalid); continue
  1460   1523                     }
  1461   1524   
  1462   1525                     #
  1463   1526                     # NOTE: Next, show the extra information associated with
  1464   1527                     #       this update script, if any.
  1465   1528                     #
  1466         -                  tqputs $channel [appendArgs \
  1467         -                      "---- fetching update script from \"" $baseUri "\" (" \
  1468         -                      $dateTime ") with notes:\n"]
         1529  +                  if {!$quiet} then {
         1530  +                    tqputs $channel [appendArgs \
         1531  +                        "---- fetching update script from \"" $baseUri \
         1532  +                        "\" (" $dateTime ") with notes:\n"]
  1469   1533   
  1470         -                  set trimNotes [string trim $notes]
         1534  +                    set trimNotes [string trim $notes]
  1471   1535   
  1472         -                  tqputs $channel [appendArgs \
  1473         -                      [expr {[string length $trimNotes] > 0 ? $trimNotes : \
  1474         -                      "<none>"}] "\n---- end of update script notes\n"]
         1536  +                    tqputs $channel [appendArgs \
         1537  +                        [expr {[string length $trimNotes] > 0 ? $trimNotes : \
         1538  +                        "<none>"}] "\n---- end of update script notes\n"]
         1539  +                  }
  1475   1540   
  1476   1541                     #
  1477   1542                     # NOTE: Next, attempt to fetch the update script data.
  1478   1543                     #
  1479   1544                     set code [catch {getUpdateScriptData $baseUri} result]
  1480   1545   
  1481   1546                     if {$code == 0} then {
................................................................................
  1483   1548                       # NOTE: Success, set the script data from the result.
  1484   1549                       #
  1485   1550                       set scriptData $result
  1486   1551                     } else {
  1487   1552                       #
  1488   1553                       # NOTE: Failure, report the error message to the log.
  1489   1554                       #
  1490         -                    tqputs $channel [appendArgs \
  1491         -                        "---- failed to fetch update script: " $result \n]
  1492         -
  1493         -                    continue
         1555  +                    if {!$quiet} then {
         1556  +                      tqputs $channel [appendArgs \
         1557  +                          "---- failed to fetch update script: " $result \n]
         1558  +                    }
         1559  +                    incr scriptCount(fail); continue
  1494   1560                     }
  1495   1561   
  1496   1562                     #
  1497   1563                     # NOTE: Next, verify that the md5, sha1, and sha512
  1498   1564                     #       hashes of the raw script data match what was
  1499   1565                     #       specified in the md5, sha1, and sha512 fields.
  1500   1566                     #
  1501   1567                     set scriptMd5 [hash normal md5 $scriptData]
  1502   1568   
  1503   1569                     if {![string equal -nocase $lineMd5 $scriptMd5]} then {
  1504         -                    tqputs $channel [appendArgs \
  1505         -                        "---- wrong md5 value \"" $scriptMd5 \
  1506         -                        "\" for update script line: " $line \"\n]
  1507         -
  1508         -                    continue
         1570  +                    if {!$quiet} then {
         1571  +                      tqputs $channel [appendArgs \
         1572  +                          "---- wrong md5 value \"" $scriptMd5 \
         1573  +                          "\" for update script line: " $line \"\n]
         1574  +                    }
         1575  +                    incr scriptCount(bad); continue
  1509   1576                     }
  1510   1577   
  1511   1578                     set scriptSha1 [hash normal sha1 $scriptData]
  1512   1579   
  1513   1580                     if {![string equal -nocase $lineSha1 $scriptSha1]} then {
  1514         -                    tqputs $channel [appendArgs \
  1515         -                        "---- wrong sha1 value \"" $scriptSha1 \
  1516         -                        "\" for update script line: " $line \"\n]
  1517         -
  1518         -                    continue
         1581  +                    if {!$quiet} then {
         1582  +                      tqputs $channel [appendArgs \
         1583  +                          "---- wrong sha1 value \"" $scriptSha1 \
         1584  +                          "\" for update script line: " $line \"\n]
         1585  +                    }
         1586  +                    incr scriptCount(bad); continue
  1519   1587                     }
  1520   1588   
  1521   1589                     set scriptSha512 [hash normal sha512 $scriptData]
  1522   1590   
  1523   1591                     if {![string equal -nocase $lineSha512 $scriptSha512]} then {
  1524         -                    tqputs $channel [appendArgs \
  1525         -                        "---- wrong sha512 value \"" $scriptSha512 \
  1526         -                        "\" for update script line: " $line \"\n]
  1527         -
  1528         -                    continue
         1592  +                    if {!$quiet} then {
         1593  +                      tqputs $channel [appendArgs \
         1594  +                          "---- wrong sha512 value \"" $scriptSha512 \
         1595  +                          "\" for update script line: " $line \"\n]
         1596  +                    }
         1597  +                    incr scriptCount(bad); continue
  1529   1598                     }
  1530   1599   
  1531   1600                     #
  1532   1601                     # NOTE: Finally, everything looks good.  Therefore, just
  1533   1602                     #       evaluate the update script and print the result.
  1534   1603                     #
  1535         -                  tqputs $channel [appendArgs \
  1536         -                      "---- evaluating update script from \"" $baseUri \
  1537         -                      \"...\n]
         1604  +                  if {!$quiet} then {
         1605  +                    tqputs $channel [appendArgs \
         1606  +                        "---- evaluating update script from \"" $baseUri \
         1607  +                        \"...\n]
         1608  +                  }
  1538   1609   
  1539   1610                     #
  1540   1611                     # NOTE: Reset the variables that will be used to contain
  1541   1612                     #       the result of the update script.
  1542   1613                     #
  1543   1614                     set code 0; set result ""
  1544   1615   
................................................................................
  1561   1632                       # NOTE: Reset manual override of the script file name
  1562   1633                       #       to be returned by [info script].
  1563   1634                       #
  1564   1635                       object invoke -flags +NonPublic Interpreter.GetActive \
  1565   1636                           PopScriptLocation true
  1566   1637                     }
  1567   1638   
  1568         -                  host result $code $result; incr scriptCount
  1569         -                  tqputs $channel "\n---- end of update script results\n"
         1639  +                  #
         1640  +                  # NOTE: Keep track of the number of update scripts that
         1641  +                  #       generate Ok and Error return codes.
         1642  +                  #
         1643  +                  if {$code == 0} then {
         1644  +                    incr scriptCount(ok)
         1645  +                  } else {
         1646  +                    incr scriptCount(error)
         1647  +                  }
         1648  +
         1649  +                  if {!$quiet} then {
         1650  +                    host result $code $result
         1651  +                    tqputs $channel "\n---- end of update script results\n"
         1652  +                  }
  1570   1653                   }
  1571   1654                 } elseif {$checkBuild && $compare < 0} then {
  1572   1655                   #
  1573   1656                   # NOTE: The patch level from the line is less, we are more
  1574   1657                   #       up-to-date than the latest version?
  1575   1658                   #
  1576         -                return [list [appendArgs "running build " $enginePatchLevel \
  1577         -                    " is newer than the latest build " $patchLevel]]
         1659  +                return [list [appendArgs \
         1660  +                    "running build " $enginePatchLevel ", dated " \
         1661  +                    $engineDateTime ", is newer than latest build " \
         1662  +                    $patchLevel ", dated " $dateTime]]
  1578   1663                 } elseif {$checkBuild} then {
  1579   1664                   #
  1580   1665                   # NOTE: The patch levels are equal, we are up-to-date.
  1581   1666                   #
  1582         -                return [list "running build is the latest"]
         1667  +                return [list [appendArgs \
         1668  +                    "running build " $enginePatchLevel ", dated " \
         1669  +                    $engineDateTime ", is the latest build"]]
  1583   1670                 }
  1584   1671               }
  1585   1672             }
  1586   1673           }
  1587   1674         }
  1588   1675   
  1589   1676         #
  1590   1677         # NOTE: Figure out what the final result should be.  If we get
  1591   1678         #       to this point when checking for a new build, something
  1592   1679         #       must have gone awry.  Otherwise, report the number of
  1593   1680         #       update scripts that were successfully processed.
  1594   1681         #
  1595   1682         if {$wantScripts} then {
  1596         -        if {$scriptCount > 0} then {
         1683  +        set scriptCount(total) [expr [join [array values scriptCount] +]]
         1684  +
         1685  +        if {$scriptCount(total) > 0} then {
  1597   1686             return [list [appendArgs \
  1598         -              "processed " $scriptCount " update scripts"]]
         1687  +              "processed " $scriptCount(total) " update scripts: " \
         1688  +              [array get scriptCount]]]
  1599   1689           } else {
  1600   1690             return [list "no update scripts were processed"]
  1601   1691           }
  1602   1692         } else {
  1603         -        return [list "cannot determine if running build is the latest"]
         1693  +        return [list "could not determine if running build is the latest"]
  1604   1694         }
  1605   1695       }
  1606   1696   
  1607   1697       proc getReturnType { object member } {
  1608   1698         if {[string length $object] == 0 || [string length $member] == 0} then {
  1609   1699           return ""
  1610   1700         }

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

    25     25       ############################ BEGIN Eagle ONLY #############################
    26     26       ###########################################################################
    27     27   
    28     28       #
    29     29       # NOTE: Commands specific to initializing the Eagle interactive shell
    30     30       #       environment should be placed here.
    31     31       #
    32         -
           32  +    proc help { args } {
           33  +      eval lappend command #help $args; debug icommand $command
           34  +      error "for interactive help please use: #help $args"
           35  +    }
           36  +
    33     37       ###########################################################################
    34     38       ############################# END Eagle ONLY ##############################
    35     39       ###########################################################################
    36     40     } else {
    37     41       ###########################################################################
    38     42       ############################# BEGIN Tcl ONLY ##############################
    39     43       ###########################################################################

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

   472    472   
   473    473       #
   474    474       # NOTE: Now, attempt to flush the test log queue, if available.
   475    475       #
   476    476       tlog ""
   477    477     }
   478    478   
   479         -  proc getTclShellFileName {} {
          479  +  proc getTclShellFileName { automatic } {
   480    480       #
   481         -    # NOTE: Check the environment variables we know about that
          481  +    # NOTE: Start out with an empty list of candiate Tcl shells.
          482  +    #
          483  +    set shells [list]
          484  +
          485  +    #
          486  +    # NOTE: Check all environment variables we know about that
   482    487       #       may contain the path where the Tcl shell is located.
   483    488       #
   484    489       foreach name [list Eagle_Tcl_Shell Tcl_Shell] {
   485    490         set value [getEnvironmentVariable $name]
   486    491   
   487    492         #
   488    493         # TODO: Possibly add a check if the file actually exists
   489    494         #       here.
   490    495         #
   491    496         if {[string length $value] > 0} then {
   492    497           #
   493         -        # NOTE: *EXTERNAL* Return verbatim, no normalization.
   494         -        #
   495         -        return $value
   496         -      }
   497         -    }
   498         -
   499         -    #
   500         -    # NOTE: None of the environment variables returned anything
   501         -    #       valid, return the fallback default.
          498  +        # NOTE: *EXTERNAL* Use verbatim, no normalization.
          499  +        #
          500  +        if {$automatic} then {
          501  +          #
          502  +          # NOTE: In automatic mode, the environment variable
          503  +          #       value simply represents another candidate
          504  +          #       Tcl shell (i.e. it does not halt the search
          505  +          #       for other candidate Tcl shells).
          506  +          #
          507  +          lappend shells $value
          508  +        } else {
          509  +          #
          510  +          # NOTE: In manual mode, the environment variable
          511  +          #       value represents an "override" and halts
          512  +          #       the search for other candidate Tcl shells.
          513  +          #
          514  +          return $value
          515  +        }
          516  +      }
          517  +    }
          518  +
          519  +    #
          520  +    # NOTE: The automatic Tcl shell detection is only available when
          521  +    #       running in Eagle.
          522  +    #
          523  +    if {[isEagle]} then {
          524  +      #
          525  +      # NOTE: Attempt to check for the "best" available dynamically
          526  +      #       loadable Tcl library and then attempt to use its
          527  +      #       "associated" Tcl shell.  A very similar block of code
          528  +      #       is also used by the [checkForTclInstalls] procedure
          529  +      #       in the constraints package.
          530  +      #
          531  +      if {[catch {tcl select -architecture} tcl] == 0} then {
          532  +        #
          533  +        # NOTE: Did we find one?  Attempt to grab the index of the
          534  +        #       version field from the returned dictionary value.
          535  +        #
          536  +        set dotVersion [getDictionaryValue $tcl version]
          537  +
          538  +        #
          539  +        # NOTE: Verify that the version we found is valid and that
          540  +        #       it conforms to the pattern we expect.
          541  +        #
          542  +        if {[string length $dotVersion] > 0 && \
          543  +            [regexp -- {^\d+\.\d+$} $dotVersion]} then {
          544  +          #
          545  +          # NOTE: Gather the list of candidate Tcl shells to check
          546  +          #       using the range of versions we are interested in,
          547  +          #       starting with the "best" available version and
          548  +          #       ending with the absolute minimum version supported
          549  +          #       by the Eagle core library.  A very similar block
          550  +          #       of code is also used by the [checkForTclShell]
          551  +          #       procedure in the constraints package.
          552  +          #
          553  +          foreach version [lsort -real -decreasing [tcl \
          554  +              versionrange -maximumversion $dotVersion]] {
          555  +            lappend shells [appendArgs \
          556  +                tclsh [string map [list . ""] $version]]
          557  +
          558  +            lappend shells [appendArgs tclsh $version]
          559  +          }
          560  +        }
          561  +      }
          562  +
          563  +      #
          564  +      # NOTE: Check each candidate Tcl shell and query its fully
          565  +      #       qualified path from it.  If it cannot be executed,
          566  +      #       we know that candidate Tcl shell is not available.
          567  +      #
          568  +      foreach shell $shells {
          569  +        if {[catch {
          570  +          getTclExecutableForTclShell $shell
          571  +        } executable] == 0 && $executable ne "error"} then {
          572  +          #
          573  +          # NOTE: It looks like this Tcl shell is available.
          574  +          #       Return the fully qualified path to it now.
          575  +          #
          576  +          return $executable
          577  +        }
          578  +      }
          579  +    }
          580  +
          581  +    #
          582  +    # NOTE: Return the fallback default.
   502    583       #
   503    584       return tclsh
   504    585     }
   505    586   
   506    587     proc getTemporaryPath {} {
   507    588       #
   508    589       # NOTE: Build the list of "temporary directory" override
................................................................................
  1339   1420         }
  1340   1421       }
  1341   1422   
  1342   1423       return $result
  1343   1424     }
  1344   1425   
  1345   1426     proc formatDecimal { value {places 4} {zeros false} } {
         1427  +    #
         1428  +    # NOTE: If the value is an empty string, do nothing and return an empty
         1429  +    #       string.
         1430  +    #
         1431  +    if {[string length $value] == 0} then {
         1432  +      return ""
         1433  +    }
         1434  +
         1435  +    #
         1436  +    # NOTE: For now, use slightly different methods for formatting floating
         1437  +    #       pointer numbers for native Tcl and Eagle.
         1438  +    #
  1346   1439       if {[isEagle] && [llength [info commands object]] > 0} then {
  1347   1440         #
  1348   1441         # HACK: This works; however, in order to do this kind of thing cleanly,
  1349   1442         #       we really need the Tcl [format] command.
  1350   1443         #
  1351   1444         set result [object invoke String Format [appendArgs "{0:0." \
  1352   1445             [string repeat [expr {$zeros ? "0" : "#"}] $places] "}"] \
................................................................................
  1354   1447   
  1355   1448         unset object; # dispose
  1356   1449       } else {
  1357   1450         #
  1358   1451         # NOTE: See, nice and clean when done in Tcl?
  1359   1452         #
  1360   1453         set result [format [appendArgs %. $places f] $value]
         1454  +
         1455  +      #
         1456  +      # HACK: Since native Tcl does not appear to expose a method to only
         1457  +      #       preserve non-zero trailing digits, we may need to manually
         1458  +      #       remove extra trailing zeros.
         1459  +      #
         1460  +      if {!$zeros} then {
         1461  +        #
         1462  +        # NOTE: Remove all trailing zeros and the trailing decimal point,
         1463  +        #       if necessary.
         1464  +        #
         1465  +        set result [string trimright [string trimright $result 0] .]
         1466  +      }
  1361   1467       }
  1362   1468   
  1363   1469       return $result
  1364   1470     }
  1365   1471   
  1366   1472     proc clearTestPercent { channel } {
  1367   1473       if {[isEagle]} then {
................................................................................
  1918   2024           #       test suite.  Make sure these commands do not already exist
  1919   2025           #       prior to attempt to adding them.
  1920   2026           #
  1921   2027           if {[llength [info commands testConstraint]] == 0} then {
  1922   2028             interp alias {} testConstraint {} haveOrAddConstraint
  1923   2029   
  1924   2030             if {!$quiet} then {
  1925         -            tqputs [getTestChannelOrDefault] [appendArgs \
  1926         -                "---- added \"testConstraint\" alias\n"]
         2031  +            tqputs [getTestChannelOrDefault] \
         2032  +                "---- added \"testConstraint\" alias\n"
  1927   2033             }
  1928   2034           }
  1929   2035   
  1930   2036           if {[llength [info commands ::tcltest::testConstraint]] == 0} then {
  1931   2037             interp alias {} ::tcltest::testConstraint {} haveOrAddConstraint
  1932   2038   
  1933   2039             if {!$quiet} then {
  1934         -            tqputs [getTestChannelOrDefault] [appendArgs \
  1935         -                "---- added \"::tcltest::testConstraint\" alias\n"]
         2040  +            tqputs [getTestChannelOrDefault] \
         2041  +                "---- added \"::tcltest::testConstraint\" alias\n"
  1936   2042             }
  1937   2043           }
  1938   2044   
  1939   2045           #
  1940   2046           # NOTE: This is needed by most tests in the Tcl test suite.  Make
  1941   2047           #       sure this command does not already exist prior to adding it.
  1942   2048           #
  1943   2049           if {[llength [info commands ::tcltest::cleanupTests]] == 0} then {
  1944   2050             proc ::tcltest::cleanupTests { args } {}
  1945   2051   
  1946   2052             if {!$quiet} then {
  1947         -            tqputs [getTestChannelOrDefault] [appendArgs \
  1948         -                "---- added \"::tcltest::cleanupTests\" procedure\n"]
         2053  +            tqputs [getTestChannelOrDefault] \
         2054  +                "---- added \"::tcltest::cleanupTests\" procedure\n"
  1949   2055             }
  1950   2056           }
  1951   2057         } else {
  1952   2058           #
  1953   2059           # NOTE: Remove the compatibility shim command aliases that we setup
  1954   2060           #       earlier.
  1955   2061           #
  1956   2062           if {[lsearch -exact [info commands] \
  1957   2063               ::tcltest::cleanupTests] != -1} then {
  1958   2064             rename ::tcltest::cleanupTests ""
  1959   2065   
  1960   2066             if {!$quiet} then {
  1961         -            tqputs $::test_channel [appendArgs \
  1962         -                "---- removed \"::tcltest::cleanupTests\" procedure\n"]
         2067  +            tqputs $::test_channel \
         2068  +                "---- removed \"::tcltest::cleanupTests\" procedure\n"
  1963   2069             }
  1964   2070           }
  1965   2071   
  1966   2072           if {[lsearch -exact [interp aliases] \
  1967   2073               ::tcltest::testConstraint] != -1} then {
  1968   2074             interp alias {} ::tcltest::testConstraint {} {}
  1969   2075   
  1970   2076             if {!$quiet} then {
  1971         -            tqputs $::test_channel [appendArgs \
  1972         -                "---- removed \"::tcltest::testConstraint\" alias\n"]
         2077  +            tqputs $::test_channel \
         2078  +                "---- removed \"::tcltest::testConstraint\" alias\n"
  1973   2079             }
  1974   2080           }
  1975   2081   
  1976   2082           if {[lsearch -exact [interp aliases] testConstraint] != -1} then {
  1977   2083             interp alias {} testConstraint {} {}
  1978   2084   
  1979   2085             if {!$quiet} then {
  1980         -            tqputs $::test_channel [appendArgs \
  1981         -                "---- removed \"testConstraint\" alias\n"]
         2086  +            tqputs $::test_channel \
         2087  +                "---- removed \"testConstraint\" alias\n"
  1982   2088             }
  1983   2089           }
  1984   2090         }
  1985   2091       }
  1986   2092   
  1987   2093       proc tresult { code result } {
  1988   2094         host result $code $result; tlog $result
................................................................................
  2134   2240             after flags =$flags
  2135   2241           }
  2136   2242         } finally {
  2137   2243           interp bgerror {} $bgerror
  2138   2244         }
  2139   2245       }
  2140   2246   
  2141         -    proc testExecTclScript { script } {
         2247  +    proc testExecTclScript { script {shell ""} } {
  2142   2248         try {
  2143   2249           #
  2144   2250           # NOTE: Get a temporary file name for the script we are going to
  2145   2251           #       use to query the machine type for the native Tcl shell.
  2146   2252           #
  2147   2253           set fileName [file tempname]
  2148   2254   
................................................................................
  2149   2255           #
  2150   2256           # NOTE: Since the native Tcl shell cannot simply evaluate a string
  2151   2257           #       supplied via the command line, write the script to be
  2152   2258           #       evaluated to the temporary file.
  2153   2259           #
  2154   2260           writeFile $fileName $script
  2155   2261   
         2262  +        #
         2263  +        # NOTE: Use the specified shell, if it is valid; otherwise, use
         2264  +        #       the configured Tcl shell.
         2265  +        #
         2266  +        if {[string length $shell] == 0} then {
         2267  +          #
         2268  +          # NOTE: Before attempting to use the configured Tcl shell, make
         2269  +          #       sure it has actually been set.
         2270  +          #
         2271  +          if {[info exists ::test_tclsh] && \
         2272  +              [string length $::test_tclsh] > 0} then {
         2273  +            set shell $::test_tclsh
         2274  +          } else {
         2275  +            #
         2276  +            # NOTE: We cannot execute the native Tcl shell because one
         2277  +            #       has not been specified, nor configured.
         2278  +            #
         2279  +            return error
         2280  +          }
         2281  +        }
         2282  +
  2156   2283           #
  2157   2284           # NOTE: Evaluate the script using the native Tcl shell, trim the
  2158   2285           #       excess whitespace from the output, and return it to the
  2159   2286           #       caller.
  2160   2287           #
  2161   2288           if {[catch {string trim \
  2162         -            [testExec $::test_tclsh [list -success Success] \
         2289  +            [testExec $shell [list -success Success] \
  2163   2290               [appendArgs \" $fileName \"]]} result] == 0} then {
  2164   2291             #
  2165   2292             # NOTE: Success, return the result to the caller.
  2166   2293             #
  2167   2294             return $result
  2168   2295           } else {
  2169   2296             #
................................................................................
  2184   2311             #       type for the native Tcl shell.
  2185   2312             #
  2186   2313             catch {file delete $fileName}
  2187   2314           }
  2188   2315         }
  2189   2316       }
  2190   2317   
  2191         -    proc getTclVersionForTclShell {} {
         2318  +    proc getTclVersionForTclShell { {shell ""} } {
  2192   2319         return [testExecTclScript {
  2193   2320           puts -nonewline stdout [info tclversion]
  2194         -      }]
         2321  +      } $shell]
  2195   2322       }
  2196   2323   
  2197         -    proc getCommandsForTclShell {} {
         2324  +    proc getCommandsForTclShell { {shell ""} } {
  2198   2325         return [testExecTclScript {
  2199   2326           puts -nonewline stdout [info commands]
  2200         -      }]
         2327  +      } $shell]
  2201   2328       }
  2202   2329   
  2203         -    proc getMachineForTclShell {} {
         2330  +    proc getMachineForTclShell { {shell ""} } {
  2204   2331         return [testExecTclScript {
  2205   2332           puts -nonewline stdout $tcl_platform(machine)
  2206         -      }]
         2333  +      } $shell]
         2334  +    }
         2335  +
         2336  +    proc getTclExecutableForTclShell { {shell ""} } {
         2337  +      return [testExecTclScript {
         2338  +        puts -nonewline stdout [info nameofexecutable]
         2339  +      } $shell]
  2207   2340       }
  2208   2341   
  2209         -    proc getTkVersionForTclShell {} {
         2342  +    proc getTkVersionForTclShell { {shell ""} } {
  2210   2343         return [testExecTclScript {
  2211   2344           puts -nonewline stdout [package require Tk]; exit
  2212         -      }]
         2345  +      } $shell]
  2213   2346       }
  2214   2347   
  2215   2348       proc getGarudaDll {} {
  2216   2349         #
  2217   2350         # NOTE: Get the Garuda DLL of the same platform (i.e. machine type)
  2218   2351         #       as the native Tcl shell.
  2219   2352         #

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

   225    225       # NOTE: If we actually found a vendor-specific testing infrastructure
   226    226       #       directory then modify the TestPath property of the current
   227    227       #       interpreter to point directly to it.
   228    228       #
   229    229       if {[string length $vendor_directory] > 0} then {
   230    230         setupInterpreterTestPath stdout $vendor_directory false
   231    231       }
          232  +
          233  +    #
          234  +    # HACK: Prevent the Eagle core test suite infrastructure from doing
          235  +    #       things that require beta 29 (or later) binaries.  This section
          236  +    #       should be removed when the Eagle beta 29 binaries are checked
          237  +    #       into the System.Data.SQLite repository.
          238  +    #
          239  +    set ::no(getTclShellFileName) 1; # NOTE: Lack of [tcl versionrange].
          240  +    set ::no(testSuiteFiles) 1; # NOTE: Lack of [hash -filename].
   232    241     }
   233    242   }
   234    243   
   235    244   ###############################################################################
   236    245   ############################### END VENDOR CODE ###############################
   237    246   ###############################################################################

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

   107    107         #       a package.  Make sure we can hash content before proceeding.
   108    108         #
   109    109         if {[isEagle] || [catch {package require sha1}] == 0} then {
   110    110           tputs $channel yes\n
   111    111   
   112    112           foreach fileName $fileNames {
   113    113             if {[isEagle]} then {
   114         -            set sha1 [hash normal sha1 [readFile $fileName]]
          114  +            #
          115  +            # NOTE: Use the relatively new -filename option to the Eagle
          116  +            #       [hash] command.
          117  +            #
          118  +            set sha1 [hash normal -filename sha1 $fileName]
   115    119             } else {
   116    120               #
   117    121               # BUGBUG: Apparently, the ActiveState tcllib sha1 package may
   118    122               #         have a bug that produces the wrong values here.  No
   119    123               #         attempt is made here to work around any such bug.
          124  +            #         For further information, please see:
          125  +            #
          126  +            #         http://core.tcl.tk/tcllib/info/ad20454023
   120    127               #
   121    128               set sha1 [sha1::sha1 -hex -filename $fileName]
   122    129             }
   123    130   
   124    131             tputs $channel [appendArgs \
   125    132                 "---- file \"" $fileName "\"... sha1 (" $sha1 ")\n"]
   126    133           }
................................................................................
   395    402   
   396    403       tputs $channel no\n
   397    404     }
   398    405   
   399    406     proc checkForFossil { channel } {
   400    407       tputs $channel "---- checking for Fossil... "
   401    408   
   402         -    if {[catch {set version [exec -- fossil version]}] == 0} then {
          409  +    if {[catch {exec -- fossil version} version] == 0} then {
   403    410         set version [string trim $version]
   404    411         set pattern {^This is fossil version (.*) \[([0-9a-f]+)\]\
   405    412             \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} UTC$}
   406    413   
   407    414         if {[regexp -- $pattern $version dummy version sourceId]} then {
   408    415           #
   409    416           # NOTE: Add a constraint to show that the Fossil executable
................................................................................
   412    419           addConstraint fossil_version
   413    420   
   414    421           #
   415    422           # NOTE: Append the version of Fossil currently in use.
   416    423           #
   417    424           append result version " " $version " \[" $sourceId \]
   418    425   
   419         -        if {[catch {set remote [exec -- fossil remote]}] == 0} then {
          426  +        if {[catch {exec -- fossil remote} remote] == 0} then {
   420    427             set remote [string trim $remote]; set valid false
   421    428   
   422    429             if {[isEagle]} then {
   423    430               #
   424    431               # NOTE: With Eagle, we can actually validate the URI.
   425    432               #
   426    433               if {[uri isvalid $remote]} then {
................................................................................
  1172   1179         addConstraint performance
  1173   1180   
  1174   1181         tputs $channel yes\n
  1175   1182       } else {
  1176   1183         tputs $channel no\n
  1177   1184       }
  1178   1185     }
         1186  +
         1187  +  proc checkForBigLists { channel } {
         1188  +    tputs $channel "---- checking for big list testing... "
         1189  +
         1190  +    #
         1191  +    # NOTE: Are we allowed to do big list testing?
         1192  +    #
         1193  +    if {![info exists ::no(bigLists)]} then {
         1194  +      if {[isEagle]} then {
         1195  +        #
         1196  +        # MONO: Using the native utility library when running on Mono to
         1197  +        #       join big lists seems to cause StackOverflowException to
         1198  +        #       be thrown.
         1199  +        #
         1200  +        if {[info exists ::no(mono)] || ![isMono] || \
         1201  +            ![haveConstraint nativeUtility]} then {
         1202  +          #
         1203  +          # NOTE: Yes, it appears that it is available.
         1204  +          #
         1205  +          addConstraint bigLists
         1206  +
         1207  +          tputs $channel yes\n
         1208  +        } else {
         1209  +          tputs $channel "no, broken on Mono with native utility\n"
         1210  +        }
         1211  +      } else {
         1212  +        addConstraint bigLists
         1213  +
         1214  +        tputs $channel yes\n
         1215  +      }
         1216  +    } else {
         1217  +      tputs $channel no\n
         1218  +    }
         1219  +  }
  1179   1220   
  1180   1221     proc checkForStackIntensive { channel } {
  1181   1222       tputs $channel "---- checking for stack intensive testing... "
  1182   1223   
  1183   1224       #
  1184   1225       # NOTE: Are we allowed to do stack intensive testing?
  1185   1226       #
................................................................................
  1279   1320           "---- checking for network connectivity to host \"" $host "\"... "]
  1280   1321   
  1281   1322       if {[isEagle]} then {
  1282   1323         #
  1283   1324         # NOTE: Running this check on the Mono 3.3.0 release build will lock
  1284   1325         #       up the process; therefore, attempt to skip it in that case.
  1285   1326         #
  1286         -      if {![isMono] || ![haveConstraint mono33]} then {
         1327  +      if {[info exists ::no(mono)] || ![isMono] || \
         1328  +          ![haveConstraint mono33]} then {
  1287   1329           #
  1288   1330           # BUGBUG: Tcl 8.4 does not like this expression (and Tcl tries to
  1289   1331           #         compile it even though it will only actually ever be
  1290   1332           #         evaluated in Eagle).
  1291   1333           #
  1292   1334           set expr {[llength [info commands uri]] > 0 && \
  1293   1335               [catch {uri ping $host $timeout} response] == 0 && \
................................................................................
  1374   1416       ############################ BEGIN Eagle ONLY #############################
  1375   1417       ###########################################################################
  1376   1418   
  1377   1419       proc checkForSoftwareUpdateTrust { channel } {
  1378   1420         tputs $channel "---- checking for software update trust... "
  1379   1421   
  1380   1422         if {[llength [info commands uri]] > 0 && \
  1381         -          [catch {uri softwareupdates} result] == 0 && \
  1382         -          $result eq "software update certificate is trusted"} then {
         1423  +          [catch {uri softwareupdates} trust] == 0 && \
         1424  +          $trust eq "software update certificate is trusted"} then {
  1383   1425           #
  1384   1426           # NOTE: Yes, it appears that we trust our software updates.
  1385   1427           #       Since this setting is off by default, the user (or
  1386   1428           #       a script evaluated by the user) must have manually
  1387   1429           #       turned it on.
  1388   1430           #
  1389   1431           addConstraint softwareUpdate
................................................................................
  1544   1586           tputs $channel no\n
  1545   1587         }
  1546   1588       }
  1547   1589   
  1548   1590       proc checkForHost { channel } {
  1549   1591         tputs $channel "---- checking for host... "
  1550   1592   
  1551         -      if {[catch {host isopen} result] == 0} then {
  1552         -        if {$result} then {
         1593  +      if {[catch {host isopen} open] == 0} then {
         1594  +        if {$open} then {
  1553   1595             addConstraint hostIsOpen
  1554   1596   
  1555   1597             tputs $channel open\n
  1556   1598           } else {
  1557         -          if {[catch {host redirected Input} result] == 0} then {
  1558         -            if {$result} then {
         1599  +          if {[catch {host redirected Input} redirected] == 0} then {
         1600  +            if {$redirected} then {
  1559   1601                 addConstraint hostInputRedirected
  1560   1602   
  1561   1603                 tputs $channel redirected\n
  1562   1604               } else {
  1563   1605                 addConstraint hostIsClosed
  1564   1606   
  1565   1607                 tputs $channel closed\n
  1566   1608               }
  1567   1609             } else {
  1568         -            tlog $result; tputs $channel error\n]
         1610  +            tlog $redirected; tputs $channel error\n
  1569   1611             }
  1570   1612           }
  1571   1613         } else {
  1572         -        tlog $result; tputs $channel error\n]
         1614  +        tlog $open; tputs $channel error\n
  1573   1615         }
  1574   1616       }
  1575   1617   
  1576   1618       proc checkForHostType { channel } {
  1577   1619         tputs $channel "---- checking for host type... "
  1578   1620   
  1579   1621         if {[set code [catch {object invoke \
................................................................................
  1625   1667   
  1626   1668       proc checkForRuntime { channel } {
  1627   1669         tputs $channel "---- checking for runtime... "
  1628   1670   
  1629   1671         #
  1630   1672         # NOTE: Are we running inside Mono (regardless of operating system)?
  1631   1673         #
  1632         -      if {[isMono]} then {
         1674  +      if {![info exists ::no(mono)] && [isMono]} then {
  1633   1675           #
  1634   1676           # NOTE: Yes, it appears that we are running inside Mono.
  1635   1677           #
  1636   1678           addConstraint mono; # running on Mono.
  1637   1679   
  1638   1680           tputs $channel [appendArgs [expr {[info exists \
  1639   1681               ::eagle_platform(runtime)] ? \
................................................................................
  1732   1774   
  1733   1775           #
  1734   1776           # NOTE: Now create a version string for use in the constraint name
  1735   1777           #       (remove the periods).
  1736   1778           #
  1737   1779           set version [string map [list . ""] $dotVersion]
  1738   1780   
  1739         -        if {[isMono]} then {
         1781  +        if {![info exists ::no(mono)] && [isMono]} then {
  1740   1782             #
  1741   1783             # NOTE: If the runtime version was found, add a test constraint
  1742   1784             #       for it now.
  1743   1785             #
  1744   1786             if {[string length $version] > 0} then {
  1745   1787                 #
  1746   1788                 # NOTE: We are running on Mono.  Keep track of the specific
................................................................................
  1885   1927           #
  1886   1928           # NOTE: The culture information is present, use it and show it.
  1887   1929           #
  1888   1930           addConstraint [appendArgs culture. [string map [list - _] $culture]]
  1889   1931   
  1890   1932           tputs $channel [appendArgs $culture \n]
  1891   1933         } else {
  1892         -        tputs $channel [appendArgs unknown \n]
         1934  +        tputs $channel unknown\n
  1893   1935         }
  1894   1936       }
  1895   1937   
  1896   1938       proc checkForThreadCulture { channel } {
  1897   1939         tputs $channel "---- checking for thread culture... "
  1898   1940   
  1899   1941         #
................................................................................
  1908   1950           # NOTE: The culture information is present, use it and show it.
  1909   1951           #
  1910   1952           addConstraint [appendArgs threadCulture. [string map [list - _] \
  1911   1953               $culture]]
  1912   1954   
  1913   1955           tputs $channel [appendArgs $culture \n]
  1914   1956         } else {
  1915         -        tputs $channel [appendArgs unknown \n]
         1957  +        tputs $channel unknown\n
  1916   1958         }
  1917   1959       }
  1918   1960   
  1919   1961       proc checkForQuiet { channel } {
  1920   1962         tputs $channel "---- checking for quiet... "
  1921   1963   
  1922   1964         if {[catch {object invoke Interpreter.GetActive Quiet} quiet] == 0 && \
................................................................................
  2199   2241   
  2200   2242         tputs $channel no\n
  2201   2243       }
  2202   2244   
  2203   2245       proc checkForTclReady { channel } {
  2204   2246         tputs $channel "---- checking for Tcl readiness... "
  2205   2247   
  2206         -      if {[catch {tcl ready} result] == 0 && $result} then {
         2248  +      if {[catch {tcl ready} ready] == 0 && $ready} then {
  2207   2249           #
  2208   2250           # NOTE: Yes, native Tcl is loaded and ready.
  2209   2251           #
  2210   2252           addConstraint tclReady
  2211   2253   
  2212         -        tputs $channel yes\n
         2254  +        #
         2255  +        # NOTE: Yes, native Tcl is ready -OR- available.
         2256  +        #
         2257  +        addConstraint tclReadyOrLibrary
         2258  +
         2259  +        #
         2260  +        # NOTE: Ok, attempt to determine the loaded Tcl version.
         2261  +        #
         2262  +        if {[catch {
         2263  +          tcl eval [tcl master] {info tclversion}
         2264  +        } version] == 0 && [regexp -- {^\d+\.\d+$} $version]} then {
         2265  +          addConstraint [appendArgs \
         2266  +              tclReady [string map [list . ""] $version]]
         2267  +
         2268  +          #
         2269  +          # NOTE: The Tcl library is ready; however, we need to add the
         2270  +          #       appropriate test constraint to indicate that a specific
         2271  +          #       version of Tcl is "either ready or available".
         2272  +          #
         2273  +          if {[haveConstraint tclLibrary86] && $version >= 8.6} then {
         2274  +            addConstraint tclReadyOrLibrary86
         2275  +          } elseif {[haveConstraint tclLibrary85] && $version >= 8.5} then {
         2276  +            addConstraint tclReadyOrLibrary85
         2277  +          } elseif {[haveConstraint tclLibrary84] && $version >= 8.4} then {
         2278  +            addConstraint tclReadyOrLibrary84
         2279  +          }
         2280  +
         2281  +          tputs $channel [appendArgs "yes (" $version ")\n"]
         2282  +        } else {
         2283  +          #
         2284  +          # NOTE: The Tcl library is ready; however, we have no idea what
         2285  +          #       version it actually is; therefore, skip adding the test
         2286  +          #       constraint to indicate that a specific version of Tcl
         2287  +          #       is "either ready or available".
         2288  +          #
         2289  +          tputs $channel yes\n
         2290  +        }
  2213   2291         } else {
         2292  +        #
         2293  +        # NOTE: The Tcl library is not ready; however, we still need to add
         2294  +        #       the appropriate test constraint to indicate that a specific
         2295  +        #       version of Tcl is "either ready or available".
         2296  +        #
         2297  +        if {[haveConstraint tclLibrary86]} then {
         2298  +          addConstraint tclReadyOrLibrary86
         2299  +        } elseif {[haveConstraint tclLibrary85]} then {
         2300  +          addConstraint tclReadyOrLibrary85
         2301  +        } elseif {[haveConstraint tclLibrary84]} then {
         2302  +          addConstraint tclReadyOrLibrary84
         2303  +        }
         2304  +
  2214   2305           tputs $channel no\n
  2215   2306         }
  2216   2307       }
  2217   2308   
  2218   2309       proc checkForTclShell { channel } {
  2219   2310         #
  2220   2311         # HACK: If this returns "error" that normally indicates an error was
  2221   2312         #       caught during [exec] (i.e. the native Tcl shell could not be
  2222   2313         #       executed).
  2223   2314         #
  2224   2315         set prefix "---- checking for Tcl shell version... "
  2225   2316   
  2226         -      if {[catch {getTclVersionForTclShell} result] == 0 && \
  2227         -          $result ne "error"} then {
         2317  +      if {[catch {getTclVersionForTclShell} version] == 0 && \
         2318  +          $version ne "error"} then {
  2228   2319           #
  2229   2320           # NOTE: Yes, a native Tcl shell appears to be available.
  2230   2321           #
  2231   2322           addConstraint tclShell
  2232   2323   
  2233   2324           #
  2234   2325           # NOTE: Now, add the version specific test constraint.
  2235   2326           #
  2236         -        addConstraint [appendArgs tclShell [string map [list . ""] $result]]
         2327  +        addConstraint [appendArgs \
         2328  +            tclShell [string map [list . ""] $version]]
  2237   2329   
  2238         -        tputs $channel [appendArgs $prefix "yes (" $result ")\n"]
         2330  +        tputs $channel [appendArgs $prefix "yes (" $version ")\n"]
  2239   2331         } else {
  2240   2332           tputs $channel [appendArgs $prefix no\n]
  2241   2333         }
  2242   2334       }
  2243   2335   
  2244   2336       proc checkForTkPackage { channel } {
  2245   2337         #
................................................................................
  2246   2338         # HACK: We do not care about the Tk version returned from this
  2247   2339         #       procedure, we only care if it returns "error" because that
  2248   2340         #       would indicate an error was caught during [exec] (i.e. the
  2249   2341         #       native Tcl shell could not be executed).
  2250   2342         #
  2251   2343         set prefix "---- checking for Tk package version... "
  2252   2344   
  2253         -      if {[catch {getTkVersionForTclShell} result] == 0 && \
  2254         -          $result ne "error"} then {
         2345  +      if {[catch {getTkVersionForTclShell} version] == 0 && \
         2346  +          $version ne "error"} then {
  2255   2347           #
  2256   2348           # NOTE: Yes, a native Tk package appears to be available.
  2257   2349           #
  2258   2350           addConstraint tkPackage
  2259   2351   
  2260         -        tputs $channel [appendArgs $prefix "yes (" $result ")\n"]
         2352  +        tputs $channel [appendArgs $prefix "yes (" $version ")\n"]
  2261   2353         } else {
  2262   2354           tputs $channel [appendArgs $prefix no\n]
  2263   2355         }
  2264   2356       }
  2265   2357   
  2266   2358       proc checkForPowerShell { channel } {
  2267   2359         tputs $channel "---- checking for PowerShell... "
................................................................................
  2496   2588             if {[string length $version] > 0} then {
  2497   2589               set nativeUtility [appendArgs \
  2498   2590                   $name . [join [lrange [split $version .] 0 1] .]]
  2499   2591             } else {
  2500   2592               set nativeUtility $name
  2501   2593             }
  2502   2594   
         2595  +          addConstraint nativeUtility
  2503   2596             addConstraint [appendArgs nativeUtility. $nativeUtility]
  2504   2597   
  2505   2598             tputs $channel [appendArgs $::eagle_platform(nativeUtility) \
  2506   2599                 " " ( $nativeUtility ) \n]
  2507   2600           } else {
  2508   2601             tputs $channel unknown\n
  2509   2602           }
................................................................................
  2539   2632           set release [object invoke Microsoft.Win32.Registry GetValue $key \
  2540   2633               Release null]
  2541   2634   
  2542   2635           if {[string is integer -strict $release] && $release >= 378389} then {
  2543   2636             #
  2544   2637             # NOTE: Yes, it appears that it is available.
  2545   2638             #
  2546         -          addConstraint dotNet45
         2639  +          addConstraint dotNet45OrHigher
         2640  +
         2641  +          #
         2642  +          # NOTE: If the "release" value is greater than or equal to 378758,
         2643  +          #       then the .NET Framework 4.5.1 is installed.
         2644  +          #
         2645  +          if {$release >= 378758} then {
         2646  +            addConstraint dotNet451
         2647  +            addConstraint dotNet451OrHigher
         2648  +
         2649  +            set version 4.5.1
         2650  +          } else {
         2651  +            addConstraint dotNet45
         2652  +
         2653  +            set version 4.5
         2654  +          }
  2547   2655   
  2548   2656             #
  2549   2657             # NOTE: Show the "release" value we found in the registry.
  2550   2658             #
  2551         -          tputs $channel [appendArgs "yes (" $release ")\n"]
         2659  +          tputs $channel [appendArgs "yes (" $release ", " $version ")\n"]
  2552   2660   
  2553   2661             #
  2554   2662             # NOTE: We are done here, return now.
  2555   2663             #
  2556   2664             return
  2557   2665           }
  2558   2666         }
................................................................................
  2579   2687           set key [appendArgs HKEY_LOCAL_MACHINE\\ \
  2580   2688               [getSoftwareRegistryKey true] {\Microsoft\VisualStudio}]
  2581   2689   
  2582   2690           #
  2583   2691           # NOTE: The versions of Visual Studio that we support.
  2584   2692           #
  2585   2693           set versions [list [list 8.0 2005] [list 9.0 2008] \
  2586         -            [list 10.0 2010] [list 11.0 2012]]
         2694  +            [list 10.0 2010] [list 11.0 2012] [list 12.0 2013]]
  2587   2695   
  2588   2696           #
  2589   2697           # NOTE: Check each version and keep track of the ones we find.
  2590   2698           #
  2591   2699           foreach version $versions {
  2592   2700             #
  2593   2701             # NOTE: Attempt to fetch the Visual Studio install directory
................................................................................
  2745   2853           checkForTclOptions checkForWindowsCommandProcessor checkForFossil \
  2746   2854           checkForEagle checkForSymbols checkForLogFile checkForGaruda \
  2747   2855           checkForShell checkForDebug checkForTk checkForVersion \
  2748   2856           checkForCommand checkForTestExec checkForTestMachine \
  2749   2857           checkForTestPlatform checkForTestConfiguration checkForTestSuffix \
  2750   2858           checkForFile checkForPathFile checkForNativeCode checkForTip127 \
  2751   2859           checkForTip194 checkForTip241 checkForTip285 checkForTip405 \
  2752         -        checkForTip426 checkForTiming checkForPerformance \
         2860  +        checkForTip426 checkForTiming checkForPerformance checkForBigLists \
  2753   2861           checkForStackIntensive checkForInteractive checkForInteractiveCommand \
  2754   2862           checkForUserInteraction checkForNetwork checkForCompileOption] false \
  2755   2863           false
  2756   2864   
  2757   2865       ###########################################################################
  2758   2866       ############################## END Tcl ONLY ###############################
  2759   2867       ###########################################################################

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

    91     91     #       or whatever project the Eagle binaries are being used by) using a
    92     92     #       Fossil binary in the PATH, if available.
    93     93     #
    94     94     if {![info exists root_path] && \
    95     95         ![info exists no(exec)] && ![info exists no(fossil)]} then {
    96     96       set pattern {^local-root:\s+(.*?)\s+$}
    97     97   
    98         -    if {[catch {set exec [exec -- fossil info]}] || \
    99         -        [regexp -line -- $pattern $exec dummy directory] == 0} then {
           98  +    if {[catch {exec -- fossil info} exec] || \
           99  +        ![regexp -line -- $pattern $exec dummy directory]} then {
   100    100         #
   101    101         # NOTE: We could not query local root directory of the source checkout
   102    102         #       from Fossil; therefore, attempt to make an educated guess.  This
   103    103         #       value will probably be wrong for any project(s) other than Eagle.
   104    104         #       In that case, this value should be overridden by that project to
   105    105         #       reflect the actual local root directory of the source checkout
   106    106         #       for that project.
................................................................................
   374    374     # NOTE: Set the default test configuration (i.e. Debug or Release), if
   375    375     #       necessary.
   376    376     #
   377    377     if {![info exists test_configuration]} then {
   378    378       set test_configuration [getPlatformInfo configuration Release]
   379    379     }
   380    380   
   381         -  #
   382         -  # NOTE: Set the Tcl shell executable to use for those specialized tests that
   383         -  #       may require it, if necessary.
   384         -  #
   385         -  if {![info exists test_tclsh]} then {
   386         -    #
   387         -    # NOTE: When running in Eagle, more complex logic is required to determine
   388         -    #       the Tcl shell to use for the various tests that require it.  Also,
   389         -    #       this same logic is used with Tcl when it is not running from an
   390         -    #       instance of the Tcl shell executable.
   391         -    #
   392         -    if {[isEagle] || ![string match tclsh* $bin_file]} then {
   393         -      if {[info exists test_flags(-tclsh)] && \
   394         -          [string length $test_flags(-tclsh)] > 0} then {
   395         -        #
   396         -        # NOTE: Use the Tcl shell specified via the command line.
   397         -        #
   398         -        set test_tclsh $test_flags(-tclsh)
   399         -      } else {
   400         -        #
   401         -        # NOTE: Check for a Tcl shell specified via the environment.
   402         -        #
   403         -        set test_tclsh [getTclShellFileName]
   404         -      }
   405         -    } else {
   406         -      set test_tclsh $bin_file
   407         -    }
   408         -  }
   409         -
   410    381     #
   411    382     # NOTE: Has automatic log file naming been disabled?
   412    383     #
   413    384     if {![info exists no(logFileName)]} then {
   414    385       #
   415    386       # NOTE: Set the log to use for test output, if necessary.
   416    387       #
   417    388       if {![info exists test_log]} then {
   418    389         set test_log [file join [getTemporaryPath] [appendArgs [file tail [info \
   419    390             nameofexecutable]] [getTestLogId] .test. [pid] .log]]
   420    391       }
   421    392     }
          393  +
          394  +  #
          395  +  # NOTE: Has native Tcl shell detection and use been disabled?
          396  +  #
          397  +  if {![info exists no(tclsh)]} then {
          398  +    #
          399  +    # NOTE: Set the Tcl shell executable to use for those specialized
          400  +    #       tests that may require it, if necessary.
          401  +    #
          402  +    if {![info exists test_tclsh]} then {
          403  +      #
          404  +      # NOTE: When running in Eagle, more complex logic is required to
          405  +      #       determine the Tcl shell to use for the various tests that
          406  +      #       require it.  Also, this same logic is used with Tcl when it
          407  +      #       is not running from an instance of the Tcl shell executable.
          408  +      #
          409  +      if {[isEagle] || ![string match tclsh* $bin_file]} then {
          410  +        if {[info exists test_flags(-tclsh)] && \
          411  +            [string length $test_flags(-tclsh)] > 0} then {
          412  +          #
          413  +          # NOTE: Use the Tcl shell specified via the command line.
          414  +          #
          415  +          set test_tclsh $test_flags(-tclsh)
          416  +        } else {
          417  +          if {![info exists no(getTclShellFileName)]} then {
          418  +            #
          419  +            # NOTE: Attempt to automatically select a Tcl shell to use.
          420  +            #
          421  +            tputs $test_channel \
          422  +                "==== WARNING: attempting automatic Tcl shell selection...\n"
          423  +
          424  +            set test_tclsh [getTclShellFileName true]
          425  +          } else {
          426  +            #
          427  +            # NOTE: Skip detection and use the fallback default.
          428  +            #
          429  +            set test_tclsh tclsh
          430  +          }
          431  +        }
          432  +      } else {
          433  +        set test_tclsh $bin_file
          434  +      }
          435  +    }
          436  +  }
   422    437   
   423    438     #
   424    439     # NOTE: When running in Eagle, check for any non-core plugins loaded into
   425    440     #       the interpreter and issue warnings if any are found.  The warning
   426    441     #       may be used to explain subsequent test failures due to the extra
   427    442     #       plugins being loaded (i.e. there are some tests are sensitive to
   428    443     #       having "unexpected" plugins loaded).
................................................................................
   537    552       if {[string length $publicKeyToken] == 0} then {
   538    553         #
   539    554         # NOTE: The Eagle core library is not strong name signed.  This is not an
   540    555         #       error, per se; however, it may cause some tests to fail and it
   541    556         #       should be reported to the user and noted in the test suite log
   542    557         #       file.
   543    558         #
   544         -      tputs $test_channel [appendArgs \
   545         -          "==== WARNING: running without any strong name signature...\n"]
          559  +      tputs $test_channel \
          560  +          "==== WARNING: running without any strong name signature...\n"
   546    561       } else {
   547    562         #
   548    563         # BUGBUG: Tcl 8.4 does not like this expression because it contains the
   549    564         #         "ni" operator (and Tcl tries to compile it even though it will
   550    565         #         only actually ever be evaluated in Eagle).
   551    566         #
   552    567         set expr {$publicKeyToken ni \
................................................................................
   691    706   
   692    707     tputs $test_channel [appendArgs "---- tests running in: \"" \
   693    708         [pwd] \"\n]
   694    709   
   695    710     tputs $test_channel [appendArgs "---- temporary files stored in: \"" \
   696    711         [getTemporaryPath] \"\n]
   697    712   
   698         -  tputs $test_channel [appendArgs "---- native Tcl shell: \"" \
   699         -      $test_tclsh \"\n]
          713  +  tputs $test_channel [appendArgs "---- native Tcl shell: " \
          714  +      [expr {[info exists test_tclsh] && [string length $test_tclsh] > 0 ? \
          715  +          [appendArgs \" $test_tclsh \"] : "<none>"}] \n]
   700    716   
   701    717     tputs $test_channel [appendArgs "---- disabled options: " \
   702    718         [formatList [lsort [array names no]] <none>] \n]
   703    719   
   704    720     #
   705    721     # NOTE: Initialize the Eagle test constraints.
   706    722     #
................................................................................
   774    790         checkForRuntime $test_channel
   775    791       }
   776    792   
   777    793       #
   778    794       # NOTE: Check the variant and/or version of the CLR that we are
   779    795       #       currently running on.
   780    796       #
   781         -    if {![info exists no(runtimeVersion)]} then {
          797  +    if {![info exists no(checkForRuntimeVersion)]} then {
   782    798         checkForRuntimeVersion $test_channel
   783    799       }
   784    800   
   785    801       #
   786    802       # NOTE: Check the framework version (i.e. regardless of runtime) that
   787    803       #       we are currently running on.
   788    804       #
................................................................................
  1856   1872       #
  1857   1873       if {![info exists no(compileOptions)]} then {
  1858   1874         #
  1859   1875         # NOTE: Has dedicated test support been enabled (at compile-time)?
  1860   1876         #
  1861   1877         if {![info exists no(compileTest)]} then {
  1862   1878           #
  1863         -        # NOTE: For test "tclLoad-1.16.1".
         1879  +        # NOTE: For tests "tclLoad-1.17.1" and "tclLoad-1.17.2".
  1864   1880           #
  1865   1881           checkForCompileOption $test_channel TEST
  1866   1882         }
  1867   1883       }
  1868   1884   
  1869   1885       ###########################################################################
  1870   1886       ########################### END Tcl Constraints ###########################
................................................................................
  2145   2161       checkForScriptLibrary $test_channel
  2146   2162     }
  2147   2163   
  2148   2164     if {![info exists no(tclOptions)]} then {
  2149   2165       checkForTclOptions $test_channel
  2150   2166     }
  2151   2167   
  2152         -  if {![info exists no(stackIntensive)]} then {
         2168  +  if {![info exists no(checkForBigLists)]} then {
         2169  +    checkForBigLists $test_channel
         2170  +  }
         2171  +
         2172  +  if {![info exists no(checkForStackIntensive)]} then {
  2153   2173       checkForStackIntensive $test_channel
  2154   2174     }
  2155   2175   
  2156   2176     if {![info exists no(windowsCommandProcessor)]} then {
  2157   2177       checkForWindowsCommandProcessor $test_channel cmd.exe
  2158   2178     }
  2159   2179   
................................................................................
  2261   2281     if {![info exists no(tip426)]} then {
  2262   2282       checkForTip426 $test_channel
  2263   2283     }
  2264   2284   
  2265   2285     #
  2266   2286     # NOTE: Has performance testing been disabled?
  2267   2287     #
  2268         -  if {![info exists no(performance)]} then {
         2288  +  if {![info exists no(checkForPerformance)]} then {
  2269   2289       checkForPerformance $test_channel
  2270   2290     }
  2271   2291   
  2272   2292     #
  2273   2293     # NOTE: Have any timing related constraints been disabled?
  2274   2294     #
  2275   2295     # BUGBUG: In Eagle, these checks for "precision" timing are not overly
................................................................................
  2380   2400     if {[isEagle]} then {
  2381   2401       #
  2382   2402       # NOTE: Get the source checkout and tags (i.e. of Eagle or whatever
  2383   2403       #       project the Eagle binaries are being used by) using a Fossil
  2384   2404       #       binary in the PATH, if available.
  2385   2405       #
  2386   2406       if {![info exists no(exec)] && ![info exists no(fossil)]} then {
  2387         -      if {[catch {set exec [exec -- fossil info]}] == 0} then {
         2407  +      if {[catch {exec -- fossil info} exec] == 0} then {
  2388   2408           set pattern {^checkout:\s+(.*?)\s+$}
  2389   2409   
  2390         -        if {[regexp -line -- $pattern $exec dummy checkout] == 0} then {
         2410  +        if {![regexp -line -- $pattern $exec dummy checkout]} then {
  2391   2411             #
  2392   2412             # NOTE: We could not query the source checkout from Fossil.
  2393   2413             #
  2394   2414             set checkout <none>
  2395   2415           }
  2396   2416   
  2397   2417           set pattern {^tags:\s+(.*?)\s+$}
  2398   2418   
  2399         -        if {[regexp -line -- $pattern $exec dummy tags] == 0} then {
         2419  +        if {![regexp -line -- $pattern $exec dummy tags]} then {
  2400   2420             #
  2401   2421             # NOTE: We could not query the tags from Fossil.
  2402   2422             #
  2403   2423             set tags <none>
  2404   2424           }
  2405   2425         } else {
  2406   2426           #

Changes to SQLite.Interop/src/win/interop.h.

     6      6    */
     7      7   
     8      8   #ifndef INTEROP_VERSION
     9      9   #define INTEROP_VERSION          "1.0.90.0"
    10     10   #endif
    11     11   
    12     12   #ifndef INTEROP_SOURCE_ID
    13         -#define INTEROP_SOURCE_ID        "0000000000000000000000000000000000000000"
           13  +#define INTEROP_SOURCE_ID        "07ecc4ebfa97eddd155df718c73523746b853a0d"
    14     14   #endif
    15     15   
    16     16   #ifndef INTEROP_SOURCE_TIMESTAMP
    17         -#define INTEROP_SOURCE_TIMESTAMP "0000-00-00 00:00:00 UTC"
           17  +#define INTEROP_SOURCE_TIMESTAMP "2013-11-27 02:15:17 UTC"
    18     18   #endif

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

     5      5    * Released to the public domain, use at your own risk!
     6      6    ********************************************************/
     7      7   
     8      8   using System.Data.SQLite;
     9      9   
    10     10   ///////////////////////////////////////////////////////////////////////////////
    11     11   
    12         -[assembly: AssemblySourceId(null)]
           12  +[assembly: AssemblySourceId("07ecc4ebfa97eddd155df718c73523746b853a0d")]
    13     13   
    14     14   ///////////////////////////////////////////////////////////////////////////////
    15     15   
    16         -[assembly: AssemblySourceTimeStamp(null)]
           16  +[assembly: AssemblySourceTimeStamp("2013-11-27 02:15:17 UTC")]