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

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

Overview
Comment:Update Eagle in externals to the latest trunk code.
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA1: 9692730698553389f9adefa15463c71949506252
User & Date: mistachkin 2013-10-26 08:39:33
Context
2013-10-26
22:02
Update the MDA configuration file for the test suite. check-in: 256e2dfd8e user: mistachkin tags: trunk
08:39
Update Eagle in externals to the latest trunk code. check-in: 9692730698 user: mistachkin tags: trunk
2013-10-17
21:58
Update estimated release date for 1.0.89.0. check-in: d801c45c81 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/bin/x64/Spilornis.dll.

cannot compute difference between binary files

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

cannot compute difference between binary files

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

  1649   1649   
  1650   1650         if {[string length $type] == 0} then {
  1651   1651           return ""
  1652   1652         }
  1653   1653   
  1654   1654         return [expr {[$type IsValueType] ? 0 : "null"}]
  1655   1655       }
         1656  +
         1657  +    proc getHostSize {} {
         1658  +      #
         1659  +      # NOTE: Attempt to query the size from the host; failing that,
         1660  +      #       return a reasonable default value.
         1661  +      #
         1662  +      if {[catch {host size} result] == 0} then {
         1663  +        return $result
         1664  +      }
         1665  +      return [list 80 25]; # TODO: Good default?
         1666  +    }
  1656   1667   
  1657   1668       proc parray { a args } {
  1658   1669         if {[llength $args] > 2} then {
  1659   1670           error "wrong # args: should be \"parray a ?pattern?\""
  1660   1671         }
  1661   1672   
  1662   1673         upvar 1 $a array
................................................................................
  1673   1684   
  1674   1685           if {$length > $maxLength} {
  1675   1686             set maxLength $length
  1676   1687           }
  1677   1688         }
  1678   1689   
  1679   1690         set maxLength [expr {$maxLength + [string length $a] + 2}]
  1680         -      set hostLength [lindex [host size] 0]
         1691  +      set hostLength [lindex [getHostSize] 0]
  1681   1692         set valueLength [expr {$hostLength - $maxLength - 5}]; # " ... "
  1682   1693   
  1683   1694         foreach name $names {
  1684   1695           #
  1685   1696           # NOTE: Format the array element name for display.
  1686   1697           #
  1687   1698           set nameString [appendArgs $a ( $name )]
................................................................................
  1721   1732           set length [string length $name]
  1722   1733   
  1723   1734           if {$length > $maxLength} {
  1724   1735             set maxLength $length
  1725   1736           }
  1726   1737         }
  1727   1738   
  1728         -      set hostLength [lindex [host size] 0]
         1739  +      set hostLength [lindex [getHostSize] 0]
  1729   1740         set valueLength [expr {$hostLength - $maxLength - 5}]; # " ... "
  1730   1741   
  1731   1742         foreach {name value} $d {
  1732   1743           #
  1733   1744           # NOTE: If the value by itself is too long to fit on one host line,
  1734   1745           #       just truncate and ellipsis it.
  1735   1746           #

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

  1338   1338           lappend result $fileName
  1339   1339         }
  1340   1340       }
  1341   1341   
  1342   1342       return $result
  1343   1343     }
  1344   1344   
  1345         -  proc formatDecimal { value {places 4} } {
         1345  +  proc formatDecimal { value {places 4} {zeros false} } {
  1346   1346       if {[isEagle] && [llength [info commands object]] > 0} then {
  1347   1347         #
  1348   1348         # HACK: This works; however, in order to do this kind of thing cleanly,
  1349   1349         #       we really need the Tcl [format] command.
  1350   1350         #
  1351   1351         set result [object invoke String Format [appendArgs "{0:0." \
  1352         -          [string repeat # $places] "}"] [set object [object invoke \
  1353         -          -create Double Parse $value]]]
         1352  +          [string repeat [expr {$zeros ? "0" : "#"}] $places] "}"] \
         1353  +          [set object [object invoke -create Double Parse $value]]]
  1354   1354   
  1355   1355         unset object; # dispose
  1356   1356       } else {
  1357   1357         #
  1358   1358         # NOTE: See, nice and clean when done in Tcl?
  1359   1359         #
  1360   1360         set result [format [appendArgs %. $places f] $value]

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

    26     26       #       versions of Mono supported by the test suite infrastructure.
    27     27       #
    28     28       return [list \
    29     29           [list 2 0] [list 2 2] [list 2 4] [list 2 6] [list 2 8] [list 2 10] \
    30     30           [list 2 11] [list 2 12] [list 3 0] [list 3 1] [list 3 2] [list 3 3] \
    31     31           [list 3 4] [list 3 5] [list 3 6]]
    32     32     }
           33  +
           34  +  proc checkForTestSuiteFiles { channel } {
           35  +    tputs $channel "---- checking for test suite files... "
           36  +
           37  +    #
           38  +    # NOTE: Start out with no test suite files to check.
           39  +    #
           40  +    set fileNames [list]
           41  +
           42  +    #
           43  +    # NOTE: Check if the base package path is available.
           44  +    #
           45  +    if {[info exists ::test_package_path]} then {
           46  +      #
           47  +      # TODO: If additional test suite files are added within the base
           48  +      #       package path, add them here as well.
           49  +      #
           50  +      foreach fileNameOnly [list \
           51  +          embed.eagle init.eagle pkgIndex.eagle pkgIndex.tcl \
           52  +          safe.eagle shell.eagle test.eagle vendor.eagle word.tcl] {
           53  +        #
           54  +        # NOTE: First, check if the file resides in the Eagle-specific
           55  +        #       package sub-directory.  Failing that, fallback to using
           56  +        #       the base package path itself.
           57  +        #
           58  +        set fileName [file join \
           59  +            $::test_package_path Eagle1.0 $fileNameOnly]
           60  +
           61  +        if {![file exists $fileName]} then {
           62  +          set fileName [file join $::test_package_path $fileNameOnly]
           63  +        }
           64  +
           65  +        #
           66  +        # NOTE: If the test suite file exists, add it to the list of file
           67  +        #       names to process.
           68  +        #
           69  +        if {[file exists $fileName]} then {
           70  +          lappend fileNames $fileName
           71  +        }
           72  +      }
           73  +    }
           74  +
           75  +    #
           76  +    # NOTE: Check if the test package path is available.
           77  +    #
           78  +    if {[info exists ::test_path]} then {
           79  +      #
           80  +      # TODO: If additional test suite files are added within the test
           81  +      #       package path, add them here as well.
           82  +      #
           83  +      foreach fileNameOnly [list \
           84  +          all.eagle constraints.eagle epilogue.eagle pkgIndex.eagle \
           85  +          pkgIndex.tcl prologue.eagle] {
           86  +        #
           87  +        # NOTE: Check if the file resides in the test package directory.
           88  +        #
           89  +        set fileName [file join $::test_path $fileNameOnly]
           90  +
           91  +        #
           92  +        # NOTE: If the test suite file exists, add it to the list of file
           93  +        #       names to process.
           94  +        #
           95  +        if {[file exists $fileName]} then {
           96  +          lappend fileNames $fileName
           97  +        }
           98  +      }
           99  +    }
          100  +
          101  +    #
          102  +    # NOTE: Did we find any test suite files?
          103  +    #
          104  +    if {[llength $fileNames] > 0} then {
          105  +      #
          106  +      # NOTE: Eagle has a built-in hashing command; however, Tcl requires
          107  +      #       a package.  Make sure we can hash content before proceeding.
          108  +      #
          109  +      if {[isEagle] || [catch {package require sha1}] == 0} then {
          110  +        tputs $channel yes\n
          111  +
          112  +        foreach fileName $fileNames {
          113  +          if {[isEagle]} then {
          114  +            set sha1 [hash normal sha1 [readFile $fileName]]
          115  +          } else {
          116  +            #
          117  +            # BUGBUG: Apparently, the ActiveState tcllib sha1 package may
          118  +            #         have a bug that produces the wrong values here.  No
          119  +            #         attempt is made here to work around any such bug.
          120  +            #
          121  +            set sha1 [sha1::sha1 -hex -filename $fileName]
          122  +          }
          123  +
          124  +          tputs $channel [appendArgs \
          125  +              "---- file \"" $fileName "\"... sha1 (" $sha1 ")\n"]
          126  +        }
          127  +
          128  +        #
          129  +        # NOTE: We are done here, return now.
          130  +        #
          131  +        return
          132  +      }
          133  +    }
          134  +
          135  +    tputs $channel no\n
          136  +  }
    33    137   
    34    138     proc checkForPlatform { channel } {
    35    139       tputs $channel "---- checking for platform... "
    36    140   
    37    141       if {[info exists ::tcl_platform(platform)]} then {
    38    142         addConstraint $::tcl_platform(platform)
    39    143   
................................................................................
  1076   1180     proc checkForStackIntensive { channel } {
  1077   1181       tputs $channel "---- checking for stack intensive testing... "
  1078   1182   
  1079   1183       #
  1080   1184       # NOTE: Are we allowed to do stack intensive testing?
  1081   1185       #
  1082   1186       if {![info exists ::no(stackIntensive)]} then {
  1083         -      addConstraint stackIntensive
         1187  +      if {[isEagle]} then {
         1188  +        #
         1189  +        # NOTE: Attempt to query for native stack checking in Eagle.
         1190  +        #
         1191  +        if {[catch {object invoke -flags +NonPublic \
         1192  +                Eagle._Components.Private.NativeStack CanQueryThread} \
         1193  +                canQueryThread] == 0 && \
         1194  +            $canQueryThread} then {
         1195  +          #
         1196  +          # NOTE: Yes, it appears that it is available.
         1197  +          #
         1198  +          addConstraint stackIntensive
  1084   1199   
  1085         -      tputs $channel yes\n
         1200  +          tputs $channel yes\n
         1201  +        } else {
         1202  +          tputs $channel no\n
         1203  +        }
         1204  +      } else {
         1205  +        addConstraint stackIntensive
         1206  +
         1207  +        tputs $channel yes\n
         1208  +      }
  1086   1209       } else {
  1087   1210         tputs $channel no\n
  1088   1211       }
  1089   1212     }
  1090   1213   
  1091   1214     proc checkForInteractive { channel } {
  1092   1215       tputs $channel "---- checking for interactive user... "
................................................................................
  1153   1276   
  1154   1277     proc checkForNetwork { channel host timeout } {
  1155   1278       tputs $channel [appendArgs \
  1156   1279           "---- checking for network connectivity to host \"" $host "\"... "]
  1157   1280   
  1158   1281       if {[isEagle]} then {
  1159   1282         #
  1160         -      # BUGBUG: Tcl 8.4 does not like this expression (and Tcl tries to
  1161         -      #         compile it even though it will only actually ever be
  1162         -      #         evaluated in Eagle).
  1163         -      #
  1164         -      set expr {[llength [info commands uri]] > 0 && \
  1165         -          [catch {uri ping $host $timeout} response] == 0 && \
  1166         -          [lindex $response 0] in [list Success TimedOut] && \
  1167         -          [string is integer -strict [lindex $response 1]] && \
  1168         -          [lindex $response 1] <= $timeout}
  1169         -
  1170         -      #
  1171         -      # NOTE: Does it look like we are able to contact the network host?
  1172         -      #
  1173         -      if {[expr $expr]} then {
  1174         -        #
  1175         -        # NOTE: Yes, it appears that it is available.
  1176         -        #
  1177         -        addConstraint [appendArgs network_ $host]
  1178         -
  1179         -        tputs $channel [appendArgs "yes (" $response ")\n"]
  1180         -      } else {
  1181         -        tputs $channel no\n
         1283  +      # NOTE: Running this check on the Mono 3.3.0 release build will lock
         1284  +      #       up the process; therefore, attempt to skip it in that case.
         1285  +      #
         1286  +      if {![isMono] || ![haveConstraint mono33]} then {
         1287  +        #
         1288  +        # BUGBUG: Tcl 8.4 does not like this expression (and Tcl tries to
         1289  +        #         compile it even though it will only actually ever be
         1290  +        #         evaluated in Eagle).
         1291  +        #
         1292  +        set expr {[llength [info commands uri]] > 0 && \
         1293  +            [catch {uri ping $host $timeout} response] == 0 && \
         1294  +            [lindex $response 0] in [list Success TimedOut] && \
         1295  +            [string is integer -strict [lindex $response 1]] && \
         1296  +            [lindex $response 1] <= $timeout}
         1297  +
         1298  +        #
         1299  +        # NOTE: Does it look like we are able to contact the network host?
         1300  +        #
         1301  +        if {[expr $expr]} then {
         1302  +          #
         1303  +          # NOTE: Yes, it appears that it is available.
         1304  +          #
         1305  +          addConstraint [appendArgs network_ $host]
         1306  +
         1307  +          tputs $channel [appendArgs "yes (" $response ")\n"]
         1308  +        } else {
         1309  +          tputs $channel no\n
         1310  +        }
         1311  +      } else {
         1312  +        tputs $channel "skipped, broken on Mono 3.3.0\n"
  1182   1313         }
  1183   1314       } else {
  1184   1315         #
  1185   1316         # HACK: Running in Tcl, just assume we have network access.
  1186   1317         #
  1187   1318         addConstraint [appendArgs network_ $host]
  1188   1319   
................................................................................
  1706   1837             "-bit " $machine "\"... "]
  1707   1838   
  1708   1839         #
  1709   1840         # NOTE: What are the machine architecture and the
  1710   1841         #       number of bits for this operating system?
  1711   1842         #
  1712   1843         if {[info exists ::tcl_platform(machine)] && \
  1713         -          [info exists ::tcl_platform(osBits)]} then {
         1844  +          [info exists ::tcl_platform(processBits)]} then {
  1714   1845           #
  1715   1846           # NOTE: Does the machine and number of bits match
  1716   1847           #       what the caller specified?
  1717   1848           #
  1718   1849           if {$::tcl_platform(machine) eq $machine && \
  1719         -            $::tcl_platform(osBits) eq $bits} then {
         1850  +            $::tcl_platform(processBits) eq $bits} then {
  1720   1851             #
  1721   1852             # NOTE: Yes, it matches.
  1722   1853             #
  1723   1854             addConstraint [appendArgs $machine . $bits bit]
  1724   1855   
  1725   1856             set result yes
  1726   1857           } else {
  1727   1858             set result no
  1728   1859           }
  1729   1860   
  1730         -        tputs $channel [appendArgs $result ", " $::tcl_platform(osBits) -bit \
  1731         -            " " $::tcl_platform(machine) \n]
         1861  +        tputs $channel [appendArgs $result ", " $::tcl_platform(processBits) \
         1862  +            -bit " " $::tcl_platform(machine) \n]
  1732   1863         } else {
  1733   1864           tputs $channel "no, unknown\n"
  1734   1865         }
  1735   1866       }
  1736   1867   
  1737   1868       proc checkForGarudaDll { channel } {
  1738   1869         #
................................................................................
  2605   2736       ###########################################################################
  2606   2737   
  2607   2738       #
  2608   2739       # NOTE: We need several of our test constraint related commands in the
  2609   2740       #       global namespace.
  2610   2741       #
  2611   2742       exportAndImportPackageCommands [namespace current] [list \
  2612         -        getKnownMonoVersions checkForPlatform checkForWindowsVersion \
  2613         -        checkForScriptLibrary checkForVariable checkForTclOptions \
  2614         -        checkForWindowsCommandProcessor checkForFossil checkForEagle \
  2615         -        checkForSymbols checkForLogFile checkForGaruda checkForShell \
  2616         -        checkForDebug checkForTk checkForVersion checkForCommand \
  2617         -        checkForTestExec checkForTestMachine checkForTestPlatform \
  2618         -        checkForTestConfiguration checkForTestSuffix checkForFile \
  2619         -        checkForPathFile checkForNativeCode checkForTip127 checkForTip194 \
  2620         -        checkForTip241 checkForTip285 checkForTip405 checkForTip426 \
  2621         -        checkForTiming checkForPerformance checkForStackIntensive \
  2622         -        checkForInteractive checkForInteractiveCommand \
         2743  +        getKnownMonoVersions checkForTestSuiteFiles checkForPlatform \
         2744  +        checkForWindowsVersion checkForScriptLibrary checkForVariable \
         2745  +        checkForTclOptions checkForWindowsCommandProcessor checkForFossil \
         2746  +        checkForEagle checkForSymbols checkForLogFile checkForGaruda \
         2747  +        checkForShell checkForDebug checkForTk checkForVersion \
         2748  +        checkForCommand checkForTestExec checkForTestMachine \
         2749  +        checkForTestPlatform checkForTestConfiguration checkForTestSuffix \
         2750  +        checkForFile checkForPathFile checkForNativeCode checkForTip127 \
         2751  +        checkForTip194 checkForTip241 checkForTip285 checkForTip405 \
         2752  +        checkForTip426 checkForTiming checkForPerformance \
         2753  +        checkForStackIntensive checkForInteractive checkForInteractiveCommand \
  2623   2754           checkForUserInteraction checkForNetwork checkForCompileOption] false \
  2624   2755           false
  2625   2756   
  2626   2757       ###########################################################################
  2627   2758       ############################## END Tcl ONLY ###############################
  2628   2759       ###########################################################################
  2629   2760     }

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

   117    117   
   118    118       #
   119    119       # NOTE: Show the current state of the memory.
   120    120       #
   121    121       catch {debug memory} memory
   122    122   
   123    123       tputs $test_channel [appendArgs "---- ending memory: " \
   124         -        [formatListAsDict $memory] \n]
          124  +        [formatListAsDict $memory <none>] \n]
   125    125   
   126    126       unset memory
   127    127   
   128    128       #
   129    129       # NOTE: Show the current state of the native stack.
   130    130       #
   131    131       catch {debug stack true} stack
   132    132   
   133    133       tputs $test_channel [appendArgs "---- ending stack: " \
   134         -        [formatListAsDict $stack] \n]
          134  +        [formatListAsDict $stack <none>] \n]
   135    135   
   136    136       unset stack
   137    137   
   138    138       #
   139    139       # NOTE: Check for and display any duplicate test names that we found.  In
   140    140       #       theory, this checking may produce false positives if a test file
   141    141       #       (or the entire test suite) is run multiple times without resetting

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

   588    588       tputs $test_channel [appendArgs "---- output encoding: " \
   589    589           $encoding \n]
   590    590   
   591    591       unset encoding
   592    592       catch {host query} host
   593    593   
   594    594       tputs $test_channel [appendArgs "---- host query: " \
   595         -        [formatListAsDict $host] \n]
          595  +        [formatListAsDict $host <none>] \n]
   596    596   
   597    597       unset host
   598    598       catch {debug memory} memory
   599    599   
   600    600       tputs $test_channel [appendArgs "---- starting memory: " \
   601         -        [formatListAsDict $memory] \n]
          601  +        [formatListAsDict $memory <none>] \n]
   602    602   
   603    603       unset memory
   604    604       catch {debug stack true} stack
   605    605   
   606    606       tputs $test_channel [appendArgs "---- starting stack: " \
   607         -        [formatListAsDict $stack] \n]
          607  +        [formatListAsDict $stack <none>] \n]
   608    608   
   609    609       unset stack
   610    610       catch {file drive} drive
   611    611   
   612    612       tputs $test_channel [appendArgs "---- system drive: " \
   613         -        [formatListAsDict $drive] \n]
          613  +        [formatListAsDict $drive <none>] \n]
   614    614   
   615    615       unset drive
   616    616     }
   617    617   
   618    618     tputs $test_channel [appendArgs "---- executable: \"" \
   619    619         $bin_file \"\n]
   620    620   
................................................................................
  1080   1080         }
  1081   1081   
  1082   1082         #
  1083   1083         # NOTE: Has Windows support been enabled (at compile-time)?
  1084   1084         #
  1085   1085         if {![info exists no(compileWindows)]} then {
  1086   1086           #
  1087         -        # NOTE: For test "garuda-1.1".
         1087  +        # NOTE: For tests "garuda-1.1" and "garuda-1.2".
  1088   1088           #
  1089   1089           checkForCompileOption $test_channel WINDOWS
  1090   1090         }
         1091  +
         1092  +      #
         1093  +      # NOTE: Has Windows Forms support been enabled (at compile-time)?
         1094  +      #
         1095  +      if {![info exists no(compileWinForms)]} then {
         1096  +        #
         1097  +        # NOTE: For tests "object-10.21", "tclLoad-1.2", "winForms-*.*".
         1098  +        #
         1099  +        checkForCompileOption $test_channel WINFORMS
         1100  +      }
  1091   1101   
  1092   1102         #
  1093   1103         # NOTE: Has native code support been enabled (at compile-time)?
  1094   1104         #
  1095   1105         if {![info exists no(compileNative)]} then {
  1096   1106           #
  1097   1107           # NOTE: For tests "debug-3.2", "expr-3.2", and "host-1.1".
................................................................................
  1100   1110         }
  1101   1111   
  1102   1112         #
  1103   1113         # NOTE: Has native package support been enabled (at compile-time)?
  1104   1114         #
  1105   1115         if {![info exists no(compileNativePackage)]} then {
  1106   1116           #
  1107         -        # NOTE: For test "garuda-1.1".
         1117  +        # NOTE: For tests "garuda-1.1" and "garuda-1.2".
  1108   1118           #
  1109   1119           checkForCompileOption $test_channel NATIVE_PACKAGE
  1110   1120         }
  1111   1121   
  1112   1122         #
  1113   1123         # NOTE: Has network support been enabled (at compile-time)?
  1114   1124         #
................................................................................
  1803   1813       }
  1804   1814   
  1805   1815       #
  1806   1816       # NOTE: Has Garuda testing support been disabled?
  1807   1817       #
  1808   1818       if {![info exists no(garudaDll)]} then {
  1809   1819         #
  1810         -      # NOTE: For test "garuda-1.1".
         1820  +      # NOTE: For tests "garuda-1.1" and "garuda-1.2".
  1811   1821         #
  1812   1822         checkForGarudaDll $test_channel
  1813   1823       }
  1814   1824   
  1815   1825       ###########################################################################
  1816   1826       ########################## END Eagle Constraints ##########################
  1817   1827       ###########################################################################
................................................................................
  1863   1873   
  1864   1874     #############################################################################
  1865   1875     ####################### BEGIN Tcl & Eagle Constraints #######################
  1866   1876     #############################################################################
  1867   1877   
  1868   1878     tputs $test_channel [appendArgs \
  1869   1879         "---- start of common (Tcl & Eagle) test constraints...\n"]
         1880  +
         1881  +  #
         1882  +  # NOTE: Check for the test suite infrastructure files...
         1883  +  #
         1884  +  if {![info exists no(testSuiteFiles)]} then {
         1885  +    checkForTestSuiteFiles $test_channel
         1886  +  }
  1870   1887   
  1871   1888     #
  1872   1889     # NOTE: Has all use of [exec] for tests been disabled?
  1873   1890     #
  1874   1891     if {![info exists no(checkForTestExec)]} then {
  1875   1892       checkForTestExec $test_channel
  1876   1893     }
................................................................................
  2474   2491         [expr {[info exists test_file] && [string length $test_file] > 0 ? \
  2475   2492         $test_file : "<none>"}] \n]
  2476   2493   
  2477   2494     #
  2478   2495     # NOTE: Show the active test constraints.
  2479   2496     #
  2480   2497     tputs $test_channel [appendArgs "---- constraints: " \
  2481         -      [formatList [lsort [getConstraints]]] \n]
         2498  +      [formatList [lsort [getConstraints]] <none>] \n]
  2482   2499   
  2483   2500     #
  2484   2501     # NOTE: Show the starting command count (for both Tcl and Eagle).
  2485   2502     #
  2486   2503     tputs $test_channel [appendArgs "---- starting command count: " \
  2487   2504         [info cmdcount] \n]
  2488   2505