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

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

Overview
Comment:Update Eagle in externals to the official beta 19 release.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: d598ffd54624b6829230941ddcabbf11e8fa85fd
User & Date: mistachkin 2011-10-23 08:58:31
Context
2011-10-29
21:16
Fix error checking by portions of the batch tools that create missing directories on an as-needed basis. check-in: 299d71992b user: mistachkin tags: trunk
2011-10-23
08:58
Update Eagle in externals to the official beta 19 release. check-in: d598ffd546 user: mistachkin tags: trunk
02:33
Add the external tools needed to build the documentation. check-in: 418f5dab8c user: mistachkin tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to Externals/Eagle/bin/Eagle.dll.

cannot compute difference between binary files

Changes to Externals/Eagle/bin/EagleShell.exe.

cannot compute difference between binary files

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

  1533   1533         #
  1534   1534         # NOTE: This should work properly in Tcl only.
  1535   1535         #
  1536   1536         # NOTE: Forget any previous commands that were imported from this
  1537   1537         #       namespace into the global namespace?
  1538   1538         #
  1539   1539         if {$forget} then {
  1540         -        namespace forget ${namespace}::*
         1540  +        namespace eval :: [list namespace forget [appendArgs $namespace ::*]]
  1541   1541         }
  1542   1542   
  1543   1543         #
  1544         -      # NOTE: Process each of the commands to be exported from this
         1544  +      # NOTE: Process each command to be exported from the specified
  1545   1545         #       namespace and import it into the global namespace, if
  1546   1546         #       necessary.
  1547   1547         #
  1548   1548         foreach export $exports {
  1549   1549           #
  1550         -        # NOTE: Force importing of our exported commands into the
  1551         -        #       global namespace?  Otherwise, see if the command is
  1552         -        #       already present in the global namespace before trying
  1553         -        #       to import it.
         1550  +        # NOTE: Force importing of our exported commands into the global
         1551  +        #       namespace?  Otherwise, see if the command is already
         1552  +        #       present in the global namespace before trying to import
         1553  +        #       it.
  1554   1554           #
  1555         -        if {$force || [llength [info commands ::$export]] == 0} then {
  1556         -          namespace export $export
         1555  +        if {$force || \
         1556  +            [llength [info commands [appendArgs :: $export]]] == 0} then {
         1557  +          #
         1558  +          # NOTE: Export the specified command from the specified namespace.
         1559  +          #
         1560  +          namespace eval $namespace [list namespace export $export]
         1561  +
         1562  +          #
         1563  +          # NOTE: Import the specified command into the global namespace.
         1564  +          #
         1565  +          set namespaceExport [appendArgs $namespace :: $export]
  1557   1566   
  1558   1567             if {$force} then {
  1559         -            namespace eval :: [list namespace import -force \
  1560         -                ${namespace}::$export]
         1568  +            namespace eval :: [list namespace import -force $namespaceExport]
  1561   1569             } else {
  1562         -            namespace eval :: [list namespace import \
  1563         -                ${namespace}::$export]
         1570  +            namespace eval :: [list namespace import $namespaceExport]
  1564   1571             }
  1565   1572           }
  1566   1573         }
  1567   1574       }
  1568   1575   
  1569   1576       #
  1570         -    # NOTE: Exports the necessary commands from this package and import
  1571         -    #       them into the global namespace.
         1577  +    # NOTE: Exports the necessary commands from this package and import them
         1578  +    #       into the global namespace.
  1572   1579       #
  1573   1580       exportAndImportPackageCommands [namespace current] [list \
  1574   1581           exportAndImportPackageCommands isEagle isMono getEnvironmentVariable \
  1575   1582           getPluginPath getDictionaryValue getColumnValue getRowColumnValue \
  1576   1583           appendArgs haveGaruda lappendArgs readFile filter map reduce \
  1577   1584           getPlatformInfo execShell] false false
  1578   1585   

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

   168    168   
   169    169     proc sourceIfValid { type fileName } {
   170    170       if {[string length $fileName] > 0} then {
   171    171         if {[file exists $fileName]} then {
   172    172           tputs $::test_channel [appendArgs \
   173    173               "---- evaluating $type file: \"" $fileName \"\n]
   174    174   
   175         -        if {[catch {uplevel 1 [list source $fileName]} error] != 0} then {
          175  +        if {[catch {uplevel 1 [list source $fileName]} error]} then {
   176    176             tputs $::test_channel [appendArgs \
   177    177                 "---- error during $type file: " $error \n]
   178    178   
   179    179             #
   180    180             # NOTE: The error has been logged, now re-throw it.
   181    181             #
   182    182             error $error $::errorInfo $::errorCode
................................................................................
   693    693   
   694    694         catch {set array(tclinterps,$index) [llength [tcl interps]]}
   695    695         catch {set array(tclthreads,$index) [llength [tcl threads]]}
   696    696         catch {set array(tclcommands,$index) [llength [tcl command list]]}
   697    697       }
   698    698     }
   699    699   
   700         -  proc reportTestStatistics { channel fileName varName } {
          700  +  proc reportTestStatistics { channel fileName statsVarName filesVarName } {
   701    701       set statistics [list afters variables commands procedures files \
   702    702           temporaryFiles channels aliases interpreters environment]
   703    703   
   704    704       if {[isEagle]} then {
   705    705         #
   706    706         # TODO: For now, tracking "leaked" assemblies is meaningless because
   707    707         #       the .NET Framework has no way to unload them without tearing
................................................................................
   711    711             namespaces processes connections transactions modules \
   712    712             delegates tcl tclinterps tclthreads tclcommands; # assemblies
   713    713       }
   714    714   
   715    715       #
   716    716       # NOTE: Show what leaked, if anything.
   717    717       #
   718         -    upvar 1 $varName array
          718  +    set count 0; upvar 1 $statsVarName array
   719    719   
   720    720       foreach statistic $statistics {
   721    721         if {$array($statistic,after) > $array($statistic,before)} then {
          722  +        incr count
          723  +
   722    724           tputs $channel [appendArgs "==== \"" $fileName "\" LEAKED " \
   723    725               $statistic \n]
   724    726   
   725    727           if {[info exists array($statistic,before,list)]} then {
   726    728             tputs $channel [appendArgs "---- " $statistic " BEFORE: " \
   727    729                 $array($statistic,before,list) \n]
   728    730           }
................................................................................
   729    731   
   730    732           if {[info exists array($statistic,after,list)]} then {
   731    733             tputs $channel [appendArgs "---- " $statistic " AFTER: " \
   732    734                 $array($statistic,after,list) \n]
   733    735           }
   734    736         }
   735    737       }
          738  +
          739  +    #
          740  +    # NOTE: Make sure this file name is recorded in the list of file names with
          741  +    #       leaking tests.
          742  +    #
          743  +    upvar 1 $filesVarName fileNames
          744  +
          745  +    if {$count > 0 && \
          746  +        [lsearch -exact $fileNames [file tail $fileName]] == -1} then {
          747  +      lappend fileNames [file tail $fileName]
          748  +    }
   736    749     }
   737    750   
   738    751     proc formatList { list {default ""} {columns 1} } {
   739    752       set count 1
   740    753       set result ""
   741    754   
   742    755       foreach item $list {
................................................................................
   874    887   
   875    888       #
   876    889       # NOTE: So far, we have run no tests.
   877    890       #
   878    891       set count 0
   879    892   
   880    893       #
   881         -    # NOTE: So far, no files have had no files with failing tests.
          894  +    # NOTE: So far, no files have had failing or leaking tests.
   882    895       #
   883    896       set failed [list]
          897  +    set leaked [list]
   884    898   
   885    899       #
   886    900       # NOTE: Process each file name we have been given by the caller...
   887    901       #
   888    902       set total [llength $fileNames]; set lastPercent -1
   889    903   
   890    904       foreach fileName $fileNames {
................................................................................
  1051   1065               #
  1052   1066               recordTestStatistics leaks after
  1053   1067   
  1054   1068               #
  1055   1069               # NOTE: Determine if any resource leaks have occurred and
  1056   1070               #       output diagnostics as necessary if they have.
  1057   1071               #
  1058         -            reportTestStatistics $channel $fileName leaks
         1072  +            reportTestStatistics $channel $fileName leaks leaked
  1059   1073             }
  1060   1074           } else {
  1061   1075             #
  1062   1076             # NOTE: This file does not actually count towards the total (i.e.
  1063   1077             #       it contains no actual tests).
  1064   1078             #
  1065   1079             incr total -1
................................................................................
  1110   1124       #
  1111   1125       clearTestPercent $channel
  1112   1126   
  1113   1127       tputs $channel [appendArgs "---- sourced " $count " test " \
  1114   1128           [expr {$count > 1 ? "files" : "file"}] \n]
  1115   1129   
  1116   1130       #
  1117         -    # NOTE: Show the files that had failing tests.
         1131  +    # NOTE: Show the files that had failing and/or leaking tests.
  1118   1132       #
  1119   1133       if {[llength $failed] > 0} then {
  1120   1134         tputs $channel [appendArgs "---- files with failing tests: " $failed \n]
  1121   1135       }
         1136  +
         1137  +    if {[llength $leaked] > 0} then {
         1138  +      tputs $channel [appendArgs "---- files with leaking tests: " $leaked \n]
         1139  +    }
  1122   1140     }
  1123   1141   
  1124   1142     proc configureTcltest { imports force } {
  1125   1143       if {[isEagle]} then {
  1126   1144         #
  1127   1145         # NOTE: Fake having the tcltest package.
  1128   1146         #
................................................................................
  1242   1260               {100.0 * ($::eagle_tests(skipped) / \
  1243   1261               double($::eagle_tests(total)))}]
  1244   1262         }
  1245   1263   
  1246   1264         return 0; # no tests were run, etc.
  1247   1265       }
  1248   1266   
  1249         -    proc cleanupThread { thread } {
         1267  +    proc cleanupThread { thread {timeout 2000} } {
  1250   1268         if {[$thread IsAlive]} then {
  1251   1269           if {[catch {$thread Interrupt} error]} then {
  1252   1270             tputs $::test_channel [appendArgs \
  1253         -              "---- failed to interrupt test thread \"" \
  1254         -              $thread "\": " $error \n]
         1271  +              "---- failed to interrupt test thread \"" $thread "\": " $error \
         1272  +              \n]
         1273  +        } else {
         1274  +          tputs $::test_channel [appendArgs "---- test thread \"" $thread \
         1275  +              "\" interrupted\n"]
  1255   1276           }
  1256   1277   
  1257   1278           if {[$thread IsAlive]} then {
  1258         -          if {[catch {$thread Abort} error]} then {
         1279  +          if {[catch {$thread Join $timeout} error]} then {
         1280  +            tputs $::test_channel [appendArgs \
         1281  +                "---- failed to join test thread \"" $thread "\": " $error \n]
         1282  +          } elseif {$error} then {
         1283  +            tputs $::test_channel [appendArgs "---- joined test thread \"" \
         1284  +                $thread \"\n]
         1285  +          } else {
  1259   1286               tputs $::test_channel [appendArgs \
  1260         -                "---- failed to abort test thread \"" \
  1261         -                $thread "\": " $error \n]
         1287  +                "---- timeout joining test thread \"" $thread " (" $timeout \
         1288  +                " milliseconds)\"\n"]
  1262   1289             }
  1263   1290   
  1264         -          if {![$thread IsAlive]} then {
  1265         -            tputs $::test_channel [appendArgs \
  1266         -                "---- test thread \"" $thread "\" aborted\n"]
         1291  +          if {[$thread IsAlive]} then {
         1292  +            if {[catch {$thread Abort} error]} then {
         1293  +              tputs $::test_channel [appendArgs \
         1294  +                  "---- failed to abort test thread \"" $thread "\": " $error \
         1295  +                  \n]
         1296  +            } else {
         1297  +              tputs $::test_channel [appendArgs "---- test thread \"" $thread \
         1298  +                  "\" aborted\n"]
         1299  +            }
  1267   1300   
  1268         -            return true; # aborted?
         1301  +            if {[$thread IsAlive]} then {
         1302  +              tputs $::test_channel [appendArgs "---- test thread \"" $thread \
         1303  +                  "\" appears to be a zombie\n"]
         1304  +            } else {
         1305  +              return true; # aborted?
         1306  +            }
         1307  +          } else {
         1308  +            return true; # joined?
  1269   1309             }
  1270   1310           } else {
  1271         -          tputs $::test_channel [appendArgs \
  1272         -              "---- test thread \"" $thread "\" interrupted\n"]
  1273         -
  1274   1311             return true; # interrupted?
  1275   1312           }
  1276   1313         } else {
  1277   1314           return true; # already dead?
  1278   1315         }
  1279   1316   
  1280   1317         return false; # still alive (or error).
  1281   1318       }
  1282   1319   
  1283   1320       proc calculateBogoCops { {milliseconds 2000} } {
         1321  +      #
         1322  +      # NOTE: Save the current background error handler for later restoration
         1323  +      #       and then reset the current background error handler to nothing.
         1324  +      #
         1325  +      set bgerror [interp bgerror {}]
         1326  +      interp bgerror {} ""
         1327  +
         1328  +      try {
         1329  +        #
         1330  +        # NOTE: Save the current [after] flags for later restoration and then
         1331  +        #       reset them to process events immediately.
         1332  +        #
         1333  +        set flags [after flags]
         1334  +        after flags =Immediate
         1335  +
         1336  +        try {
         1337  +          set code [catch {
         1338  +            #
         1339  +            # NOTE: Schedule the event to cancel the script we are about to
         1340  +            #       evaluate, capturing the name so we can cancel it later, if
         1341  +            #       necessary.
         1342  +            #
         1343  +            set event [after $milliseconds [list interp cancel]]
         1344  +
         1345  +            #
         1346  +            # HACK: There is the potential for a "race condition" here.  If the
         1347  +            #       specified number of milliseconds elapses before (or after)
         1348  +            #       entering the [catch] script block (below) then the resulting
         1349  +            #       script cancellation error will not be caught and we will be
         1350  +            #       unable to return the correct result to the caller.
         1351  +            #
         1352  +            set before [info cmdcount]
         1353  +            catch {time {nop} -1}; # uses the [time] internal busy loop.
         1354  +            set after [info cmdcount]
         1355  +
         1356  +            #
         1357  +            # HACK: Mono has a bug that results in excessive trailing zeros
         1358  +            #       here (Mono bug #655780).
         1359  +            #
         1360  +            if {[isMono]} then {
         1361  +              expr {double(($after - $before) / ($milliseconds / 1000.0))}
         1362  +            } else {
         1363  +              expr {($after - $before) / ($milliseconds / 1000.0)}
         1364  +            }
         1365  +          } result]
         1366  +
         1367  +          #
         1368  +          # NOTE: If we failed to calculate the number of commands-per-second
         1369  +          #       due to some subtle race condition [as explained above], return
         1370  +          #       an obviously invalid result instead.
         1371  +          #
         1372  +          if {$code == 0} then {
         1373  +            return $result
         1374  +          } else {
         1375  +            return 0
         1376  +          }
         1377  +        } finally {
         1378  +          if {[info exists event]} then {
         1379  +            catch {after cancel $event}
         1380  +          }
         1381  +
         1382  +          after flags =$flags
         1383  +        }
         1384  +      } finally {
         1385  +        interp bgerror {} $bgerror
         1386  +      }
         1387  +    }
         1388  +
         1389  +    proc evalWithTimeout { script {milliseconds 2000} {resultVarName ""} } {
         1390  +      #
         1391  +      # NOTE: Save the current background error handler for later restoration
         1392  +      #       and then reset the current background error handler to nothing.
         1393  +      #
  1284   1394         set bgerror [interp bgerror {}]
  1285   1395         interp bgerror {} ""
  1286   1396   
  1287   1397         try {
         1398  +        #
         1399  +        # NOTE: Save the current [after] flags for later restoration and then
         1400  +        #       reset them to process events immediately.
         1401  +        #
  1288   1402           set flags [after flags]
  1289   1403           after flags =Immediate
  1290   1404   
  1291   1405           try {
  1292         -          set event [after $milliseconds [list interp cancel]]
  1293         -
  1294         -          set before [info cmdcount]
  1295         -          catch {time {nop} -1}; # internal busy loop.
  1296         -          set after [info cmdcount]
  1297         -
  1298   1406             #
  1299         -          # HACK: Mono has a bug that results in excessive trailing zeros
  1300         -          #       here (Mono bug #655780).
         1407  +          # NOTE: Evaluate the specified script in the context of the caller,
         1408  +          #       returning the result to the caller.
  1301   1409             #
  1302         -          if {[isMono]} then {
  1303         -            return [expr \
  1304         -                {double(($after - $before) / ($milliseconds / 1000.0))}]
  1305         -          } else {
  1306         -            return [expr {($after - $before) / ($milliseconds / 1000.0)}]
         1410  +          if {[string length $resultVarName] > 0} then {
         1411  +            upvar 1 $resultVarName result
  1307   1412             }
         1413  +
         1414  +          return [catch {
         1415  +            #
         1416  +            # NOTE: Schedule the event to cancel the script we are about to
         1417  +            #       evaluate, capturing the name so we can cancel it later, if
         1418  +            #       necessary.
         1419  +            #
         1420  +            set event [after $milliseconds [list interp cancel]]
         1421  +
         1422  +            #
         1423  +            # NOTE: Evaluate the script in the context of the caller.
         1424  +            #
         1425  +            uplevel 1 $script
         1426  +          } result]
  1308   1427           } finally {
  1309   1428             if {[info exists event]} then {
  1310   1429               catch {after cancel $event}
  1311   1430             }
  1312   1431   
  1313   1432             after flags =$flags
  1314   1433           }

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

   121    121         if {![info exists ::no(compileNetwork)]} then {
   122    122           addConstraint compile.NETWORK
   123    123         }
   124    124   
   125    125         tputs $channel no\n
   126    126       }
   127    127     }
          128  +
          129  +  proc checkForSymbols { channel name {constraint ""} } {
          130  +    set fileName [file normalize [appendArgs [file rootname $name] .pdb]]
          131  +
          132  +    tputs $channel [appendArgs "---- checking for symbols \"" $fileName \
          133  +        "\"... "]
          134  +
          135  +    if {[file exists $fileName]} then {
          136  +      #
          137  +      # NOTE: The file appears to have associated symbols available.
          138  +      #
          139  +      if {[string length $constraint] > 0} then {
          140  +        addConstraint [appendArgs symbols_ $constraint]
          141  +      } else {
          142  +        addConstraint [appendArgs symbols_ [file tail $name]]
          143  +      }
          144  +
          145  +      tputs $channel yes\n
          146  +    } else {
          147  +      tputs $channel no\n
          148  +    }
          149  +  }
   128    150   
   129    151     proc checkForLogFile { channel } {
   130    152       tputs $channel "---- checking for log file... "
   131    153   
   132    154       if {[info exists ::test_log] && \
   133    155           [string length $::test_log] > 0 && \
   134    156           [file exists $::test_log]} then {
................................................................................
   531    553   
   532    554         tputs $channel yes\n
   533    555       } else {
   534    556         tputs $channel no\n
   535    557       }
   536    558     }
   537    559   
   538         -  proc checkForTiming { channel threshold } {
          560  +  proc checkForTiming { channel threshold {tries 2} } {
   539    561       tputs $channel "---- checking for precision timing... "
   540    562   
   541    563       #
   542         -    # NOTE: Are we allowed to do precision timing tests?
          564  +    # HACK: Sometimes the first try takes quite a bit longer than subsequent
          565  +    #       tries.  We attempt to bypass this problem by retrying a set number
          566  +    #       of times (which can be overridden by the caller) before giving up.
   543    567       #
   544         -    if {![info exists ::no(timing)]} then {
          568  +    for {set try 0} {$try < $tries} {incr try} {
   545    569         #
   546    570         # NOTE: Attempt to block for exactly one second.
   547    571         #
   548    572         set start [expr {[clock clicks -milliseconds] & 0x7fffffff}]
   549    573         after 1000; # wait for "exactly" one second.
   550    574         set stop [expr {[clock clicks -milliseconds] & 0x7fffffff}]
   551    575   
................................................................................
   555    579         #
   556    580         set difference [expr {abs($stop - $start - 1000)}]
   557    581   
   558    582         #
   559    583         # NOTE: Are we within the threshold specified by the caller?
   560    584         #
   561    585         if {$difference >= 0 && $difference <= $threshold} then {
          586  +        #
          587  +        # NOTE: We appear to be capable of fairly precise timing.
          588  +        #
   562    589           addConstraint timing
   563    590   
   564    591           tputs $channel [appendArgs "yes (0 <= " $difference " <= " \
   565         -            $threshold " milliseconds)\n"]
   566         -      } else {
   567         -        tputs $channel [appendArgs "no (0 <= " $difference " > " \
   568         -            $threshold " milliseconds)\n"]
          592  +            $threshold " milliseconds, tried " [expr {$try + 1}] \
          593  +            " " [expr {$try > 0 ? "times" : "time"}] ")\n"]
          594  +
          595  +        #
          596  +        # NOTE: We are done here, return now.
          597  +        #
          598  +        return
   569    599         }
   570         -    } else {
   571         -      tputs $channel no\n
   572    600       }
          601  +
          602  +    tputs $channel [appendArgs "no (0 <= " $difference " > " \
          603  +        $threshold " milliseconds)\n"]
   573    604     }
   574    605   
   575    606     proc checkForPerformance { channel } {
   576    607       tputs $channel "---- checking for performance testing... "
   577    608   
   578    609       #
   579    610       # NOTE: Are we allowed to do performance testing?
................................................................................
  1641   1672       # NOTE: We need several of our test constraint related commands in the
  1642   1673       #       global namespace.
  1643   1674       #
  1644   1675       exportAndImportPackageCommands [namespace current] [list checkForPlatform \
  1645   1676           checkForEagle checkForGaruda checkForShell checkForDebug checkForTk \
  1646   1677           checkForVersion checkForCommand checkForFile checkForNativeCode \
  1647   1678           checkForTip127 checkForTip194 checkForTip241 checkForTip285 \
  1648         -        checkForPerformance checkForTiming checkForInteractive checkForLogFile \
  1649         -        checkForNetwork checkForCompileOption checkForUserInteraction] false \
  1650         -        false
         1679  +        checkForPerformance checkForTiming checkForInteractive checkForSymbols \
         1680  +        checkForLogFile checkForNetwork checkForCompileOption \
         1681  +        checkForUserInteraction] false false
  1651   1682   
  1652   1683       ###########################################################################
  1653   1684       ############################## END Tcl ONLY ###############################
  1654   1685       ###########################################################################
  1655   1686     }
  1656   1687   
  1657   1688     #
  1658   1689     # NOTE: Provide the Eagle test constraints package to the interpreter.
  1659   1690     #
  1660   1691     package provide EagleTestConstraints \
  1661   1692       [expr {[isEagle] ? [info engine PatchLevel] : 1.0}]
  1662   1693   }
  1663   1694   

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

    46     46       #       sub-directory inside of the "Library" project directory
    47     47       #       simply due to the links contained in the project file that
    48     48       #       actually point to the "lib\Eagle1.0" sub-directory under the
    49     49       #       solution directory.
    50     50       #
    51     51       # WARNING: The Eagle package name and version are hard-coded here.
    52     52       #
           53  +    set pkg_dir Eagle1.0; # TODO: Change me.
           54  +
    53     55       if {![file exists [file join $base_path lib]] || \
    54     56           ![file isdirectory [file join $base_path lib]] || \
    55         -        ![file exists [file join $base_path lib Eagle1.0]] || \
    56         -        ![file isdirectory [file join $base_path lib Eagle1.0]] || \
    57         -        ![file exists [file join $base_path lib Eagle1.0 init.eagle]] || \
    58         -        ![file isfile [file join $base_path lib Eagle1.0 init.eagle]]} then {
           57  +        ![file exists [file join $base_path lib $pkg_dir]] || \
           58  +        ![file isdirectory [file join $base_path lib $pkg_dir]] || \
           59  +        ![file exists [file join $base_path lib $pkg_dir init.eagle]] || \
           60  +        ![file isfile [file join $base_path lib $pkg_dir init.eagle]]} then {
    59     61         #
    60         -      # NOTE: We do not bother to check if the "lib" sub-directory
    61         -      #       actually exists as a child of this one.  This is the
    62         -      #       previous (legacy) behavior (i.e. where we always went
    63         -      #       up two levels to the base directory).
           62  +      # NOTE: We do not bother to check if the "lib" sub-directory actually
           63  +      #       exists as a child of this one.  This is the previous (legacy)
           64  +      #       behavior (i.e. where we always went up two levels to the base
           65  +      #       directory).
    64     66         #
    65     67         set base_path [file dirname $base_path]
    66     68       }
           69  +
           70  +    unset pkg_dir
    67     71     }
    68     72   
    69     73     #
    70     74     # NOTE: Set the local root directory of the source checkout (i.e. of
    71     75     #       Eagle or whatever project the Eagle binaries are being used by).
    72     76     #
    73     77     if {![info exists root_path]} then {
................................................................................
    89     93         # NOTE: We extracted the local root directory of the source checkout
    90     94         #       from Fossil.  Now, make sure it is fully normalized and has no
    91     95         #       trailing slashes.
    92     96         #
    93     97         set root_path [file normalize $directory]
    94     98       }
    95     99   
    96         -    unset -nocomplain directory exec pattern
          100  +    unset -nocomplain directory dummy exec pattern
    97    101     }
    98    102   
    99    103     #
   100    104     # NOTE: Set the executable file name for the process, if
   101    105     #       necessary.
   102    106     #
   103    107     if {![info exists bin_file]} then {
................................................................................
   654    658         #
   655    659         # NOTE: Can we access the local database?
   656    660         #
   657    661         checkForDatabase $test_channel $test_database
   658    662         unset password user timeout database server
   659    663       }
   660    664   
          665  +    #
          666  +    # NOTE: Has symbol testing support been disabled?
          667  +    #
          668  +    if {![info exists no(assemblySymbols)]} then {
          669  +      checkForSymbols $test_channel [lindex [info assembly] end]
          670  +    }
          671  +
   661    672       #
   662    673       # NOTE: Has quiet testing support been disabled?
   663    674       #
   664    675       if {![info exists no(quiet)]} then {
   665    676         #
   666    677         # NOTE: For tests "basic-1.36", "debug-1.3", "debug-1.4", "object-10.*",
   667    678         #       and "perf-2.2".
................................................................................
   827    838         #
   828    839         if {![info exists no(compileXml)]} then {
   829    840           #
   830    841           # NOTE: For tests "commands-1.4", "object-7.3" and "xml-1.1.*".
   831    842           #
   832    843           checkForCompileOption $test_channel XML
   833    844         }
          845  +
          846  +      #
          847  +      # NOTE: Has serialization support been enabled (at compile-time)?
          848  +      #
          849  +      if {![info exists no(compileSerialization)]} then {
          850  +        #
          851  +        # NOTE: For test "interp-1.10".
          852  +        #
          853  +        checkForCompileOption $test_channel SERIALIZATION
          854  +      }
   834    855   
   835    856         #
   836    857         # NOTE: Has dedicated test support been enabled (at compile-time)?
   837    858         #
   838    859         if {![info exists no(compileTest)]} then {
   839    860           #
   840    861           # NOTE: For tests "basic-1.20", "basic-1.21", "function-1.1",
................................................................................
  1469   1490     if {![info exists no(eagle)]} then {
  1470   1491       checkForEagle $test_channel
  1471   1492     }
  1472   1493   
  1473   1494     if {![info exists no(noLogFile)]} then {
  1474   1495       checkForLogFile $test_channel
  1475   1496     }
         1497  +
         1498  +  if {![info exists no(symbols)]} then {
         1499  +    checkForSymbols $test_channel [info nameofexecutable]
         1500  +  }
  1476   1501   
  1477   1502     if {![info exists no(garuda)]} then {
  1478   1503       checkForGaruda $test_channel
  1479   1504     }
  1480   1505   
  1481   1506     if {![info exists no(shell)]} then {
  1482   1507       checkForShell $test_channel
................................................................................
  1637   1662   
  1638   1663         if {[isMono]} then {
  1639   1664           #
  1640   1665           # HACK: We need something to go into the log file.
  1641   1666           #
  1642   1667           set timeStamp [lindex $timeStamp 0]
  1643   1668         } else {
  1644         -        set timeStamp [clock format [clock scan $timeStamp] -iso]
         1669  +        set timeStamp [clock format [clock scan $timeStamp] -iso -isotimezone]
  1645   1670         }
  1646   1671       } else {
  1647   1672         set timeStamp <none>
  1648   1673       }
  1649   1674   
  1650   1675       tputs $test_channel [appendArgs "---- build: " \
  1651   1676           [list [getPlatformInfo engine <none>]] " " \