Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
| Comment: | Added a substitution to config.tcl.in to capture Tea's prefered name for
the zip archive the package will produce.
New version of practcl from tcllib Update from the core of tclZipfs.c to fix windows platform compile problems |
|---|---|
| Downloads: | Tarball | ZIP archive |
| Timelines: | family | ancestors | descendants | both | practcl |
| Files: | files | file ages | folders |
| SHA3-256: |
fb80000a6f58f424eba811b85d434edd |
| User & Date: | hypnotoad 2018-01-22 17:23:04.913 |
Context
|
2018-02-23
| ||
| 18:02 | Pulling changes from trunk check-in: 6f6a4f642f user: hypnotoad tags: practcl | |
|
2018-01-22
| ||
| 17:23 |
Added a substitution to config.tcl.in to capture Tea's prefered name for
the zip archive the package will produce.
New version of practcl from tcllib Update from the core of tclZipfs.c to fix windows platform compile problems check-in: fb80000a6f user: hypnotoad tags: practcl | |
|
2018-01-17
| ||
| 15:59 |
Added facilities to mount data blocks as zip archives
Updated practcl from tcllib with new headers for non tip430 kits check-in: 1871415cb9 user: hypnotoad tags: practcl | |
Changes
Changes to compat/tclZipfs.c.
| ︙ | ︙ | |||
2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 |
Tcl_ListObjAppendElement(interp, result, Tcl_NewStringObj(z->name, -1));
}
}
Unlock();
return TCL_OK;
}
Tcl_Obj *TclZipfs_TclLibrary(void) {
if(zipfs_literal_tcl_library) {
return Tcl_NewStringObj(zipfs_literal_tcl_library,-1);
} else {
Tcl_Obj *vfsinitscript;
int found=0;
| > > > > > > > > > > > > > > > > > > | 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 |
Tcl_ListObjAppendElement(interp, result, Tcl_NewStringObj(z->name, -1));
}
}
Unlock();
return TCL_OK;
}
#if defined(_WIN32) || defined(_WIN64)
#define LIBRARY_SIZE 64
static int
ToUtf(
const WCHAR *wSrc,
char *dst)
{
char *start;
start = dst;
while (*wSrc != '\0') {
dst += Tcl_UniCharToUtf(*wSrc, dst);
wSrc++;
}
*dst = '\0';
return (int) (dst - start);
}
#endif
Tcl_Obj *TclZipfs_TclLibrary(void) {
if(zipfs_literal_tcl_library) {
return Tcl_NewStringObj(zipfs_literal_tcl_library,-1);
} else {
Tcl_Obj *vfsinitscript;
int found=0;
|
| ︙ | ︙ | |||
4418 4419 4420 4421 4422 4423 4424 |
return TCL_OK;
#else
ZIPFS_ERROR(interp,"no zlib available");
return TCL_ERROR;
#endif
}
| < < < < < < < < < < < < < < < < < < < < | 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 |
return TCL_OK;
#else
ZIPFS_ERROR(interp,"no zlib available");
return TCL_ERROR;
#endif
}
static int TclZipfs_AppHook_FindTclInit(const char *archive){
Tcl_Obj *vfsinitscript;
int found;
if(zipfs_literal_tcl_library) {
return TCL_ERROR;
}
if(TclZipfs_Mount(NULL, ZIPFS_ZIP_MOUNT, archive, NULL)) {
|
| ︙ | ︙ |
Changes to config.tcl.in.
| ︙ | ︙ | |||
64 65 66 67 68 69 70 71 72 73 74 75 76 77 |
TEA_PLATFORM {@TEA_PLATFORM@}
TEA_WINDOWINGSYSTEM {@TEA_WINDOWINGSYSTEM@}
TEA_SYSTEM {@TEA_SYSTEM@}
TEACUP_OS {@TEACUP_OS@}
TEACUP_ARCH {@TEACUP_ARCH@}
TEACUP_TOOLSET {@TEACUP_TOOLSET@}
TEACUP_PROFILE {@TEACUP_PROFILE@}
PRACTCL_DEFS {@PRACTCL_DEFS@}
PRACTCL_TOOLSET {@PRACTCL_TOOLSET@}
PRACTCL_SHARED_LIB {@PRACTCL_SHARED_LIB@}
PRACTCL_STATIC_LIB {@PRACTCL_STATIC_LIB@}
PRACTCL_STUB_LIB {@PRACTCL_STUB_LIB@}
PRACTCL_LIBS {@PKG_LIBS@ @LIBS@}
| > | 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
TEA_PLATFORM {@TEA_PLATFORM@}
TEA_WINDOWINGSYSTEM {@TEA_WINDOWINGSYSTEM@}
TEA_SYSTEM {@TEA_SYSTEM@}
TEACUP_OS {@TEACUP_OS@}
TEACUP_ARCH {@TEACUP_ARCH@}
TEACUP_TOOLSET {@TEACUP_TOOLSET@}
TEACUP_PROFILE {@TEACUP_PROFILE@}
TEACUP_ZIPFILE {@PACKAGE_NAME@-@PACKAGE_VERSION@-@[email protected]}
PRACTCL_DEFS {@PRACTCL_DEFS@}
PRACTCL_TOOLSET {@PRACTCL_TOOLSET@}
PRACTCL_SHARED_LIB {@PRACTCL_SHARED_LIB@}
PRACTCL_STATIC_LIB {@PRACTCL_STATIC_LIB@}
PRACTCL_STUB_LIB {@PRACTCL_STUB_LIB@}
PRACTCL_LIBS {@PKG_LIBS@ @LIBS@}
|
| ︙ | ︙ |
Changes to practcl.tcl.
1 2 3 4 5 | ### # Amalgamated package for practcl # Do not edit directly, tweak the source in src/ and rerun # build.tcl ### | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 |
###
# Amalgamated package for practcl
# Do not edit directly, tweak the source in src/ and rerun
# build.tcl
###
package provide practcl 0.11
namespace eval ::practcl {}
###
# START: httpwget/wget.tcl
###
###
# Tool to download file from the web
|
| ︙ | ︙ | |||
1122 1123 1124 1125 1126 1127 1128 |
append buffer {
set dir [lindex $::PATHSTACK end]
set ::PATHSTACK [lrange $::PATHSTACK 0 end-1]
}
return $buffer
}
| < < < < < | 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 |
append buffer {
set dir [lindex $::PATHSTACK end]
set ::PATHSTACK [lrange $::PATHSTACK 0 end-1]
}
return $buffer
}
proc ::practcl::installDir {d1 d2} {
puts [format {%*sCreating %s} [expr {4 * [info level]}] {} [file tail $d2]]
file delete -force -- $d2
file mkdir $d2
foreach ftail [glob -directory $d1 -nocomplain -tails *] {
set f [file join $d1 $ftail]
if {[file isdirectory $f] && [string compare CVS $ftail]} {
|
| ︙ | ︙ | |||
1159 1160 1161 1162 1163 1164 1165 |
proc ::practcl::copyDir {d1 d2 {toplevel 1}} {
#if {$toplevel} {
# puts [list ::practcl::copyDir $d1 -> $d2]
#}
#file delete -force -- $d2
file mkdir $d2
| > > > > > > > | > | | | | | | > > > > > > | > | | | | | | < | < < | | < < | | < < < < < < < < < < | 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 |
proc ::practcl::copyDir {d1 d2 {toplevel 1}} {
#if {$toplevel} {
# puts [list ::practcl::copyDir $d1 -> $d2]
#}
#file delete -force -- $d2
file mkdir $d2
if {[file isfile $d1]} {
file copy -force $d1 $d2
set ftail [file tail $d1]
if {$::tcl_platform(platform) eq {unix}} {
file attributes [file join $d2 $ftail] -permissions 0644
} else {
file attributes [file join $d2 $ftail] -readonly 1
}
} else {
foreach ftail [glob -directory $d1 -nocomplain -tails *] {
set f [file join $d1 $ftail]
if {[file isdirectory $f] && [string compare CVS $ftail]} {
copyDir $f [file join $d2 $ftail] 0
} elseif {[file isfile $f]} {
file copy -force $f [file join $d2 $ftail]
if {$::tcl_platform(platform) eq {unix}} {
file attributes [file join $d2 $ftail] -permissions 0644
} else {
file attributes [file join $d2 $ftail] -readonly 1
}
}
}
}
}
###
# END: installutil.tcl
###
###
# START: makeutil.tcl
###
###
# Backward compatible Make facilities
# These were used early in development and are consdiered deprecated
###
proc ::practcl::trigger {args} {
::practcl::LOCAL make trigger {*}$args
foreach {name obj} [::practcl::LOCAL make objects] {
set ::make($name) [$obj do]
}
}
proc ::practcl::depends {args} {
::practcl::LOCAL make depends {*}$args
}
proc ::practcl::target {name info {action {}}} {
set obj [::practcl::LOCAL make task $name $info $action]
set ::make($name) 0
set filename [$obj define get filename]
if {$filename ne {}} {
set ::target($name) $filename
}
}
###
# END: makeutil.tcl
###
###
# START: class metaclass.tcl
###
::oo::class create ::practcl::metaclass {
|
| ︙ | ︙ | |||
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 |
}
default {
array $submethod define {*}$args
}
}
}
method graft args {
my variable organs
if {[llength $args] == 1} {
error "Need two arguments"
}
set object {}
foreach {stub object} $args {
| > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 |
}
default {
array $submethod define {*}$args
}
}
}
method meta {submethod args} {
my variable meta
if {![info exists meta]} {
set meta {}
}
switch $submethod {
dump {
return $meta
}
add {
set field [lindex $args 0]
if {![dict exists $meta $field]} {
dict set meta $field {}
}
foreach arg [lrange $args 1 end] {
if {$arg ni [dict get $meta $field]} {
dict lappend meta $field $arg
}
}
return [dict get $meta $field]
}
remove {
set field [lindex $args 0]
if {![dict exists meta $field]} {
return
}
set rlist [lrange $args 1 end]
set olist [dict get $meta $field]
set nlist {}
foreach arg $olist {
if {$arg in $rlist} continue
lappend nlist $arg
}
dict set meta $field $nlist
return $nlist
}
exists {
return [dict exists $meta {*}$args]
}
getnull -
get {
if {[dict exists $meta {*}$args]} {
return [dict get $meta {*}$args]
}
return {}
}
cget {
set field [lindex $args 0]
if {[dict exists $meta $field]} {
return [dict get $meta $field]
}
return [lindex $args 1]
}
set {
if {[llength $args]==1} {
foreach {field value} $args {
dict set meta [string trimright $field :]: $value
}
} else {
set field [lindex $args end-1]
set value [lindex $args end]
dict set meta {*}[lrange $args 0 end-2] [string trimright $field :]: $value
}
}
default {
error "Valid: add cget dump exists get getnull remove set"
}
}
}
method graft args {
my variable organs
if {[llength $args] == 1} {
error "Need two arguments"
}
set object {}
foreach {stub object} $args {
|
| ︙ | ︙ | |||
1482 1483 1484 1485 1486 1487 1488 |
oo::class create ::practcl::toolset {
###
# find or fake a key/value list describing this project
###
method config.sh {} {
return [my read_configuration]
}
| | > > > > > > > > > > > > > > > > > | 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 |
oo::class create ::practcl::toolset {
###
# find or fake a key/value list describing this project
###
method config.sh {} {
return [my read_configuration]
}
method BuildDir {PWD} {
set name [my define get name]
set debug [my define get debug 0]
if {[my <project> define get LOCAL 0]} {
return [my define get builddir [file join $PWD local $name]]
}
if {$debug} {
return [my define get builddir [file join $PWD debug $name]]
} else {
return [my define get builddir [file join $PWD pkg $name]]
}
}
method MakeDir {srcdir} {
return $srcdir
}
method read_configuration {} {
my variable conf_result
if {[info exists conf_result]} {
return $conf_result
}
set result {}
set name [my define get name]
|
| ︙ | ︙ | |||
1591 1592 1593 1594 1595 1596 1597 |
}
set srcdir [my SourceRoot]
set PWD [pwd]
cd $srcdir
::practcl::dotclexec $critcl {*}$args
cd $PWD
}
| | < < < | < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < | 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 |
}
set srcdir [my SourceRoot]
set PWD [pwd]
cd $srcdir
::practcl::dotclexec $critcl {*}$args
cd $PWD
}
method make-autodetect {} {}
}
oo::objdefine ::practcl::toolset {
method select object {
|
| ︙ | ︙ | |||
1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 |
###
# START: class toolset gcc.tcl
###
::oo::class create ::practcl::toolset.gcc {
superclass ::practcl::toolset
method build-compile-sources {PROJECT COMPILE CPPCOMPILE INCLUDES} {
set objext [my define get OBJEXT o]
set EXTERN_OBJS {}
set OBJECTS {}
set result {}
set builddir [$PROJECT define get builddir]
file mkdir [file join $builddir objs]
| > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 |
###
# START: class toolset gcc.tcl
###
::oo::class create ::practcl::toolset.gcc {
superclass ::practcl::toolset
method Autoconf {} {
###
# Re-run autoconf for this project
# Not a good idea in practice... but in the right hands it can be useful
###
set pwd [pwd]
set srcdir [file normalize [my define get srcdir]]
cd $srcdir
foreach template {configure.ac configure.in} {
set input [file join $srcdir $template]
if {[file exists $input]} {
puts "autoconf -f $input > [file join $srcdir configure]"
exec autoconf -f $input > [file join $srcdir configure]
}
}
cd $pwd
}
method BuildDir {PWD} {
set name [my define get name]
set debug [my define get debug 0]
if {[my <project> define get LOCAL 0]} {
return [my define get builddir [file join $PWD local $name]]
}
if {$debug} {
return [my define get builddir [file join $PWD debug $name]]
} else {
return [my define get builddir [file join $PWD pkg $name]]
}
}
method ConfigureOpts {} {
set opts {}
set builddir [my define get builddir]
if {[my define get broken_destroot 0]} {
set PREFIX [my <project> define get prefix_broken_destdir]
} else {
set PREFIX [my <project> define get prefix]
}
switch [my define get name] {
tcl {
set opts [::practcl::platform::tcl_core_options [my <project> define get TEACUP_OS]]
}
tk {
set opts [::practcl::platform::tk_core_options [my <project> define get TEACUP_OS]]
}
}
puts [list [self] ConfigureOpts [my <project> define get HOST]]
if {[my <project> define get CONFIG_SITE] != {}} {
lappend opts --host=[my <project> define get HOST]
}
set inside_msys [string is true -strict [my <project> define get MSYS_ENV 0]]
lappend opts --with-tclsh=[info nameofexecutable]
if {![my <project> define get LOCAL 0]} {
set obj [my <project> tclcore]
if {$obj ne {}} {
if {$inside_msys} {
lappend opts --with-tcl=[::practcl::file_relative [file normalize $builddir] [$obj define get builddir]]
} else {
lappend opts --with-tcl=[file normalize [$obj define get builddir]]
}
}
if {[my define get tk 0]} {
set obj [my <project> tkcore]
if {$obj ne {}} {
if {$inside_msys} {
lappend opts --with-tk=[::practcl::file_relative [file normalize $builddir] [$obj define get builddir]]
} else {
lappend opts --with-tk=[file normalize [$obj define get builddir]]
}
}
}
} else {
lappend opts --with-tcl=[file join $PREFIX lib]
if {[my define get tk 0]} {
lappend opts --with-tk=[file join $PREFIX lib]
}
}
lappend opts {*}[my define get config_opts]
if {![regexp -- "--prefix" $opts]} {
lappend opts --prefix=$PREFIX --exec-prefix=$PREFIX
}
if {[my define get debug 0]} {
lappend opts --enable-symbols=true
}
#--exec_prefix=$PREFIX
#if {$::tcl_platform(platform) eq "windows"} {
# lappend opts --disable-64bit
#}
if {[my define get static 1]} {
lappend opts --disable-shared
#--disable-stubs
#
} else {
lappend opts --enable-shared
}
return $opts
}
# Detect what directory contains the Makefile template
method MakeDir {srcdir} {
set localsrcdir $srcdir
if {[file exists [file join $srcdir generic]]} {
my define add include_dir [file join $srcdir generic]
}
set os [my <project> define get TEACUP_OS]
switch $os {
windows {
if {[file exists [file join $srcdir win]]} {
my define add include_dir [file join $srcdir win]
}
if {[file exists [file join $srcdir win Makefile.in]]} {
set localsrcdir [file join $srcdir win]
}
}
default {
if {[file exists [file join $srcdir $os]]} {
my define add include_dir [file join $srcdir $os]
}
if {[file exists [file join $srcdir unix]]} {
my define add include_dir [file join $srcdir unix]
}
if {[file exists [file join $srcdir $os Makefile.in]]} {
set localsrcdir [file join $srcdir $os]
} elseif {[file exists [file join $srcdir unix Makefile.in]]} {
set localsrcdir [file join $srcdir unix]
}
}
}
return $localsrcdir
}
method make-autodetect {} {
set srcdir [my define get srcdir]
set localsrcdir [my define get localsrcdir]
if {$srcdir eq $localsrcdir} {
if {![file exists [file join $srcdir tclconfig install-sh]]} {
# ensure we have tclconfig with all of the trimmings
set teapath {}
if {[file exists [file join $srcdir .. tclconfig install-sh]]} {
set teapath [file join $srcdir .. tclconfig]
} else {
set tclConfigObj [::practcl::LOCAL tool tclconfig]
$tclConfigObj load
set teapath [$tclConfigObj define get srcdir]
}
set teapath [file normalize $teapath]
#file mkdir [file join $srcdir tclconfig]
if {[catch {file link -symbolic [file join $srcdir tclconfig] $teapath}]} {
::practcl::copyDir [file join $teapath] [file join $srcdir tclconfig]
}
}
}
set builddir [my define get builddir]
file mkdir $builddir
if {![file exists [file join $localsrcdir configure]]} {
if {[file exists [file join $localsrcdir autogen.sh]]} {
cd $localsrcdir
catch {exec sh autogen.sh >>& [file join $builddir autoconf.log]}
cd $::CWD
}
}
set opts [my ConfigureOpts]
if {[file exists [file join $builddir autoconf.log]]} {
file delete [file join $builddir autoconf.log]
}
::practcl::debug [list PKG [my define get name] CONFIGURE {*}$opts]
::practcl::log [file join $builddir autoconf.log] [list CONFIGURE {*}$opts]
cd $builddir
if {[my <project> define get CONFIG_SITE] ne {}} {
set ::env(CONFIG_SITE) [my <project> define get CONFIG_SITE]
}
puts [list [my define get name]]
puts [list builddir: $builddir]
puts [list srcdir: $srcdir]
puts [list localsrcdir: $localsrcdir]
puts [list HOST [my <project> define get HOST]]
puts [list HOST [my <project> define get HOST]]
puts [list OPTIONS: $opts]
catch {exec sh [file join $localsrcdir configure] {*}$opts >>& [file join $builddir autoconf.log]}
cd $::CWD
}
method make-clean {} {
set builddir [file normalize [my define get builddir]]
catch {::practcl::domake $builddir clean}
}
method make-compile {} {
set name [my define get name]
set srcdir [my define get srcdir]
if {[my define get static 1]} {
puts "BUILDING Static $name $srcdir"
} else {
puts "BUILDING Dynamic $name $srcdir"
}
cd $::CWD
set builddir [file normalize [my define get builddir]]
file mkdir $builddir
if {![file exists [file join $builddir Makefile]]} {
my Configure
}
if {[file exists [file join $builddir make.tcl]]} {
if {[my define get debug 0]} {
::practcl::domake.tcl $builddir debug all
} else {
::practcl::domake.tcl $builddir all
}
} else {
::practcl::domake $builddir all
}
}
method make-install DEST {
set PWD [pwd]
set builddir [my define get builddir]
if {[my <project> define get LOCAL 0] || $DEST eq {}} {
if {[file exists [file join $builddir make.tcl]]} {
puts "[self] Local INSTALL (Practcl)"
::practcl::domake.tcl $builddir install
} else {[my define get broken_destroot 0] == 0} {
puts "[self] Local INSTALL (TEA)"
::practcl::domake $builddir install
}
} else {
if {[file exists [file join $builddir make.tcl]]} {
# Practcl builds can inject right to where we need them
puts "[self] VFS INSTALL $DEST (Practcl)"
::practcl::domake.tcl $builddir install-package $DEST
} elseif {[my define get broken_destroot 0] == 0} {
# Most modern TEA projects understand DESTROOT in the makefile
puts "[self] VFS INSTALL $DEST (TEA)"
::practcl::domake $builddir install DESTDIR=[::practcl::file_relative $builddir $DEST]
} else {
# But some require us to do an install into a fictitious filesystem
# and then extract the gooey parts within.
# (*cough*) TkImg
set PREFIX [my <project> define get prefix]
set BROKENROOT [::practcl::msys_to_tclpath [my <project> define get prefix_broken_destdir]]
file delete -force $BROKENROOT
file mkdir $BROKENROOT
::practcl::domake $builddir $install
::practcl::copyDir $BROKENROOT [file join $DEST [string trimleft $PREFIX /]]
file delete -force $BROKENROOT
}
}
cd $PWD
}
method build-compile-sources {PROJECT COMPILE CPPCOMPILE INCLUDES} {
set objext [my define get OBJEXT o]
set EXTERN_OBJS {}
set OBJECTS {}
set result {}
set builddir [$PROJECT define get builddir]
file mkdir [file join $builddir objs]
|
| ︙ | ︙ | |||
2211 2212 2213 2214 2215 2216 2217 |
###
###
# START: class toolset msvc.tcl
###
::oo::class create ::practcl::toolset.msvc {
superclass ::practcl::toolset
| > > > > | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | > > > > > > > > > > > > > > > > > > > | | | | > > > > > > > | | | | | > | > > > > > > > > > > > > > > > > > > > > > > > | | < | < < | | 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 |
###
###
# START: class toolset msvc.tcl
###
::oo::class create ::practcl::toolset.msvc {
superclass ::practcl::toolset
# MSVC always builds in the source directory
method BuildDir {PWD} {
set srcdir [my define get srcdir]
return $srcdir
}
# Do nothing
method make-autodetect {} {
}
method make-clean {} {
set PWD [pwd]
set srcdir [my define get srcdir]
cd $srcdir
catch {::practcl::doexec nmake -f makefile.vc clean}
cd $PWD
}
method make-compile {} {
set srcdir [my define get srcdir]
if {[my define get static 1]} {
puts "BUILDING Static $name $srcdir"
} else {
puts "BUILDING Dynamic $name $srcdir"
}
cd $srcdir
if {[file exists [file join $srcdir make.tcl]]} {
if {[my define get debug 0]} {
::practcl::domake.tcl $srcdir debug all
} else {
::practcl::domake.tcl $srcdir all
}
} else {
if {[file exists [file join $srcdir makefile.vc]]} {
::practcl::doexec nmake -f makefile.vc INSTALLDIR=[my <project> define get installdir] {*}[my NmakeOpts] release
} elseif {[file exists [file join $srcdir win makefile.vc]]} {
cd [file join $srcdir win]
::practcl::doexec nmake -f makefile.vc INSTALLDIR=[my <project> define get installdir] {*}[my NmakeOpts] release
} else {
error "No make.tcl or makefile.vc found for project $name"
}
}
}
method make-install DEST {
set PWD [pwd]
set srcdir [my define get srcdir]
cd $srcdir
if {$DEST eq {}} {
error "No destination given"
}
if {[my <project> define get LOCAL 0] || $DEST eq {}} {
if {[file exists [file join $srcdir make.tcl]]} {
# Practcl builds can inject right to where we need them
puts "[self] Local Install (Practcl)"
::practcl::domake.tcl $srcdir install
} else {
puts "[self] Local Install (Nmake)"
::practcl::doexec nmake -f makefile.vc {*}[my NmakeOpts] install
}
} else {
if {[file exists [file join $srcdir make.tcl]]} {
# Practcl builds can inject right to where we need them
puts "[self] VFS INSTALL $DEST (Practcl)"
::practcl::domake.tcl $srcdir install-package $DEST
} else {
puts "[self] VFS INSTALL $DEST"
::practcl::doexec nmake -f makefile.vc INSTALLDIR=$DEST {*}[my NmakeOpts] install
}
}
cd $PWD
}
# Detect what directory contains the Makefile template
method MakeDir {srcdir} {
set localsrcdir $srcdir
if {[file exists [file join $srcdir generic]]} {
my define add include_dir [file join $srcdir generic]
}
if {[file exists [file join $srcdir win]]} {
my define add include_dir [file join $srcdir win]
}
if {[file exists [file join $srcdir makefile.vc]]} {
set localsrcdir [file join $srcdir win]
}
return $localsrcdir
}
method NmakeOpts {} {
set opts {}
set builddir [file normalize [my define get builddir]]
if {[my <project> define exists tclsrcdir]} {
###
# On Windows we are probably running under MSYS, which doesn't deal with
# spaces in filename well
###
set TCLSRCDIR [::practcl::file_relative [file normalize $builddir] [file normalize [file join $::CWD [my <project> define get tclsrcdir] ..]]]
set TCLGENERIC [::practcl::file_relative [file normalize $builddir] [file normalize [file join $::CWD [my <project> define get tclsrcdir] .. generic]]]
lappend opts TCLDIR=[file normalize $TCLSRCDIR]
#--with-tclinclude=$TCLGENERIC
}
if {[my <project> define exists tksrcdir]} {
set TKSRCDIR [::practcl::file_relative [file normalize $builddir] [file normalize [file join $::CWD [my <project> define get tksrcdir] ..]]]
set TKGENERIC [::practcl::file_relative [file normalize $builddir] [file normalize [file join $::CWD [my <project> define get tksrcdir] .. generic]]]
#lappend opts --with-tk=$TKSRCDIR --with-tkinclude=$TKGENERIC
lappend opts TKDIR=[file normalize $TKSRCDIR]
}
return $opts
}
}
###
# END: class toolset msvc.tcl
###
###
# START: class target.tcl
###
::oo::class create ::practcl::make_obj {
superclass ::practcl::metaclass
constructor {module_object name info {action_body {}}} {
my variable define triggered domake
set triggered 0
set domake 0
set define(name) $name
set define(action) {}
array set define $info
my select
my initialize
foreach {stub obj} [$module_object child organs] {
my graft $stub $obj
}
if {$action_body ne {}} {
set define(action) $action_body
}
}
method do {} {
my variable domake
return $domake
}
method check {} {
my variable needs_make domake
if {$domake} {
return 1
}
if {[info exists needs_make]} {
return $needs_make
}
set make_objects [my <module> make objects]
set needs_make 0
foreach item [my define get depends] {
if {![dict exists $make_objects $item]} continue
set depobj [dict get $make_objects $item]
if {$depobj eq [self]} {
puts "WARNING [self] depends on itself"
continue
}
if {[$depobj check]} {
set needs_make 1
}
}
if {!$needs_make} {
foreach filename [my output] {
if {$filename ne {} && ![file exists $filename]} {
set needs_make 1
}
}
}
return $needs_make
}
method output {} {
set result {}
set filename [my define get filename]
if {$filename ne {}} {
lappend result $filename
}
foreach filename [my define get files] {
if {$filename ne {}} {
lappend result $filename
}
}
return $result
}
method reset {} {
my variable triggered domake needs_make
set triggerd 0
set domake 0
set needs_make 0
}
method triggers {} {
my variable triggered domake define
if {$triggered} {
return $domake
}
set triggered 1
set make_objects [my <module> make objects]
foreach item [my define get depends] {
if {![dict exists $make_objects $item]} continue
set depobj [dict get $make_objects $item]
if {$depobj eq [self]} {
puts "WARNING [self] triggers itself"
continue
} else {
set r [$depobj check]
if {$r} {
$depobj triggers
}
}
}
set domake 1
my <module> make trigger {*}[my define get triggers]
}
}
###
# END: class target.tcl
###
###
|
| ︙ | ︙ | |||
3653 3654 3655 3656 3657 3658 3659 |
my variable links
set object [::practcl::object new [self] {*}$args]
foreach linktype [$object linktype] {
lappend links($linktype) $object
}
return $object
}
| | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 |
my variable links
set object [::practcl::object new [self] {*}$args]
foreach linktype [$object linktype] {
lappend links($linktype) $object
}
return $object
}
method install-headers args {}
###
# Target handling
###
method make {command args} {
my variable make_object
if {![info exists make_object]} {
set make_object {}
}
switch $command {
pkginfo {
###
# Build local variables needed for install
###
package require platform
set result {}
set dat [my define dump]
set PKG_DIR [dict get $dat name][dict get $dat version]
dict set result PKG_DIR $PKG_DIR
dict with dat {}
if {![info exists DESTDIR]} {
set DESTDIR {}
}
dict set result profile [::platform::identify]
dict set result os $::tcl_platform(os)
dict set result platform $::tcl_platform(platform)
foreach {field value} $dat {
switch $field {
includedir -
mandir -
datadir -
libdir -
libfile -
name -
output_tcl -
version -
authors -
license -
requires {
dict set result $field $value
}
TEA_PLATFORM {
dict set result platform $value
}
TEACUP_OS {
dict set result os $value
}
TEACUP_PROFILE {
dict set result profile $value
}
TEACUP_ZIPFILE {
dict set result zipfile $value
}
}
}
if {![dict exists $result zipfile]} {
dict set result zipfile "[dict get $result name]-[dict get $result version]-[dict get $result profile].zip"
}
return $result
}
objects {
return $make_object
}
object {
set name [lindex $args 0]
if {[dict exists $make_object $name]} {
return [dict get $make_object $name]
}
return {}
}
reset {
foreach {name obj} $make_object {
$obj reset
}
}
trigger {
foreach {name obj} $make_object {
if {$name in $args} {
$obj triggers
}
}
}
depends {
foreach {name obj} $make_object {
if {$name in $args} {
$obj check
}
}
}
filename {
set name [lindex $args 0]
if {[dict exists $make_object $name]} {
return [[dict get $make_object $name] define get filename]
}
}
task -
target -
add {
set name [lindex $args 0]
set info [uplevel #0 [list subst [lindex $args 1]]]
set body [lindex $args 2]
set nspace [namespace current]
if {[dict exist $make_object $name]} {
set obj [dict get $$make_object $name]
} else {
set obj [::practcl::make_obj new [self] $name $info $body]
dict set make_object $name $obj
dict set target_make $name 0
dict set target_trigger $name 0
}
if {[dict exists $info aliases]} {
foreach item [dict get $info aliases] {
if {![dict exists $make_object $item]} {
dict set make_object $item $obj
}
}
}
return $obj
}
todo {
foreach {name obj} $make_object {
if {[$obj do]} {
lappend result $name
}
}
}
do {
global CWD SRCDIR project SANDBOX
foreach {name obj} $make_object {
if {[$obj do]} {
eval [$obj define get action]
}
}
}
}
}
method child which {
switch $which {
organs {
return [list project [my define get project] module [self]]
}
}
}
|
| ︙ | ︙ | |||
4342 4343 4344 4345 4346 4347 4348 |
}
# Backward compadible call
method generate-make path {
my build-Makefile $path [self]
}
| < < < < < | 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 |
}
# Backward compadible call
method generate-make path {
my build-Makefile $path [self]
}
method linktype {} {
return library
}
# Create a "package ifneeded"
# Args are a list of aliases for which this package will answer to
method package-ifneeded {args} {
|
| ︙ | ︙ | |||
4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 |
###
# Standalone class to manage code distribution
# This class is intended to be mixed into another class
# (Thus the lack of ancestors)
###
oo::class create ::practcl::distribution {
method DistroMixIn {} {
my define set scm none
}
method Sandbox {} {
if {[my define exists sandbox]} {
return [my define get sandbox]
| > > > > > > > > > > | 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 |
###
# Standalone class to manage code distribution
# This class is intended to be mixed into another class
# (Thus the lack of ancestors)
###
oo::class create ::practcl::distribution {
method scm_info {} {
return {
scm None
hash {}
maxdate {}
tags {}
isodate {}
}
}
method DistroMixIn {} {
my define set scm none
}
method Sandbox {} {
if {[my define exists sandbox]} {
return [my define get sandbox]
|
| ︙ | ︙ | |||
4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 |
###
# START: class distro fossil.tcl
###
oo::class create ::practcl::distribution.fossil {
superclass ::practcl::distribution
# Clone the source
method ScmClone {} {
set srcdir [my SrcDir]
if {[file exists [file join $srcdir .fslckout]]} {
return
}
if {[file exists [file join $srcdir _FOSSIL_]]} {
| > > > > > > > > > | 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 |
###
# START: class distro fossil.tcl
###
oo::class create ::practcl::distribution.fossil {
superclass ::practcl::distribution
method scm_info {} {
set info [next]
dict set info scm fossil
foreach {field value} [::practcl::fossil_status [my define get srcdir]] {
dict set info $field $value
}
return $info
}
# Clone the source
method ScmClone {} {
set srcdir [my SrcDir]
if {[file exists [file join $srcdir .fslckout]]} {
return
}
if {[file exists [file join $srcdir _FOSSIL_]]} {
|
| ︙ | ︙ | |||
5194 5195 5196 5197 5198 5199 5200 |
###
oo::class create ::practcl::subproject {
superclass ::practcl::module
method _MorphPatterns {} {
return {{::practcl::subproject.@name@} {::practcl::@name@} {@name@} {::practcl::subproject}}
}
| | > > > > > < | | | 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 |
###
oo::class create ::practcl::subproject {
superclass ::practcl::module
method _MorphPatterns {} {
return {{::practcl::subproject.@name@} {::practcl::@name@} {@name@} {::practcl::subproject}}
}
method BuildDir {PWD} {
return [my define get srcdir]
}
method child which {
switch $which {
organs {
# A library can be a project, it can be a module. Any
# subordinate modules will indicate their existance
return [list project [self] module [self]]
}
}
}
method compile {} {}
method go {} {
::practcl::distribution select [self]
set name [my define get name]
my define set builddir [my BuildDir [my define get masterpath]]
my define set builddir [my BuildDir [my define get masterpath]]
my sources
}
# Install project into the local build system
method install args {}
method linktype {} {
|
| ︙ | ︙ | |||
5486 5487 5488 5489 5490 5491 5492 |
set prefix [my <project> define get prefix [file normalize [file join ~ tcl]]]
set srcdir [my define get srcdir]
lappend options --prefix $prefix --exec-prefix $prefix
my define set config_opts $options
my go
my clean
my compile
| | | 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 |
set prefix [my <project> define get prefix [file normalize [file join ~ tcl]]]
set srcdir [my define get srcdir]
lappend options --prefix $prefix --exec-prefix $prefix
my define set config_opts $options
my go
my clean
my compile
my make-install {}
}
method project-compile-products {} {}
method ComputeInstall {} {
if {[my define exists install]} {
switch [my define get install] {
|
| ︙ | ︙ | |||
5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 |
}
}
}
}
method go {} {
next
my ComputeInstall
my define set builddir [my BuildDir [my define get masterpath]]
}
method linker-products {configdict} {
if {![my define get static 0]} {
return {}
| > | 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 |
}
}
}
}
method go {} {
next
::practcl::distribution select [self]
my ComputeInstall
my define set builddir [my BuildDir [my define get masterpath]]
}
method linker-products {configdict} {
if {![my define get static 0]} {
return {}
|
| ︙ | ︙ | |||
5573 5574 5575 5576 5577 5578 5579 |
}
return $result
}
method BuildDir {PWD} {
set name [my define get name]
set debug [my define get debug 0]
| < | < > > < < < < < < < < < < < < < < < < < < < < < < < < | < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < | < < < < < < < < < | 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 |
}
return $result
}
method BuildDir {PWD} {
set name [my define get name]
set debug [my define get debug 0]
if {[my <project> define get LOCAL 0]} {
return [my define get builddir [file join $PWD local $name]]
}
if {$debug} {
return [my define get builddir [file join $PWD debug $name]]
} else {
return [my define get builddir [file join $PWD pkg $name]]
}
}
method compile {} {
set name [my define get name]
set PWD $::CWD
cd $PWD
my unpack
set srcdir [file normalize [my SrcDir]]
set localsrcdir [my MakeDir $srcdir]
my define set localsrcdir $localsrcdir
my Collate_Source $PWD
###
# Build a starter VFS for both Tcl and wish
###
set srcdir [my define get srcdir]
if {[my define get static 1]} {
puts "BUILDING Static $name $srcdir"
} else {
puts "BUILDING Dynamic $name $srcdir"
}
my make-compile
cd $PWD
}
method Configure {} {
cd $::CWD
my unpack
::practcl::toolset select [self]
set srcdir [file normalize [my define get srcdir]]
set builddir [file normalize [my define get builddir]]
file mkdir $builddir
my make-autodetect
}
method install DEST {
set PWD [pwd]
set PREFIX [my <project> define get prefix]
###
# Handle teapot installs
|
| ︙ | ︙ | |||
5708 5709 5710 5711 5712 5713 5714 |
set dest [file join $DEST [string trimleft $PREFIX /] lib [file tail $teapath]]
::practcl::copyDir $teapath $dest
return
}
}
}
my compile
| < < < < < < < < < < < < < < < < < < < < < < < | < < < < < < < < < < < < < < < < < < < < < < | 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 |
set dest [file join $DEST [string trimleft $PREFIX /] lib [file tail $teapath]]
::practcl::copyDir $teapath $dest
return
}
}
}
my compile
my make-install $DEST
cd $PWD
}
}
oo::class create ::practcl::subproject.tea {
superclass ::practcl::subproject.binary
}
|
| ︙ | ︙ | |||
5788 5789 5790 5791 5792 5793 5794 |
###
# START: class subproject core.tcl
###
oo::class create ::practcl::subproject.core {
superclass ::practcl::subproject.binary
| < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < | < < < < < < < | < < < < < < < < < | < < | < < < < < < < < < < < < < < < < < < < < < | 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 |
###
# START: class subproject core.tcl
###
oo::class create ::practcl::subproject.core {
superclass ::practcl::subproject.binary
method env-bootstrap {} {}
method env-present {} {
set PREFIX [my <project> define get prefix]
set name [my define get name]
set fname [file join $PREFIX lib ${name}Config.sh]
return [file exists $fname]
}
method env-install {} {
my unpack
set os [::practcl::local_os]
set prefix [my <project> define get prefix [file normalize [file join ~ tcl]]]
lappend options --prefix $prefix --exec-prefix $prefix
my define set config_opts $options
puts [list [self] OS [dict get $os TEACUP_OS] options $options]
my go
my compile
my make-install {}
}
method go {} {
my define set core_binary 1
next
}
method linktype {} {
return {subordinate core.library}
}
}
###
# END: class subproject core.tcl
###
###
# START: class tool.tcl
|
| ︙ | ︙ |