Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
| Comment: | Updating a few calls to ::debug to point to ::practcl::debug instead |
|---|---|
| Downloads: | Tarball | ZIP archive | SQL archive |
| Timelines: | family | ancestors | descendants | both | practcl |
| Files: | files | file ages | folders |
| SHA1: |
d0a296b832951c13413c96b10b3521b9 |
| User & Date: | hypnotoad 2016-10-20 18:59:40 |
Context
|
2016-10-22
| ||
| 01:00 |
Bumped version to 0.7
Added support for Tcl 8.5 by either reimplementing features or providing an alternate implementation Added a local preference file for storing persistent data Removed a lot of chatty PUTS statements Creates an object called ::pratcl::LOCAL which stores the local platform data, and can act as a project for the purpose of installing local build tools Added a facility to load a package from tcllib (and go so far as to install a resident tcllib) Created a modular plugin architecture for software distribution and local tools check-in: 7890e70c40 user: hypnotoad tags: practcl | |
|
2016-10-20
| ||
| 18:59 | Updating a few calls to ::debug to point to ::practcl::debug instead check-in: d0a296b832 user: hypnotoad tags: practcl | |
| 16:59 | Branch to allow practcl to properly handle core_zip_vfs Closed-Leaf check-in: fae8456ce9 user: hypnotoad tags: core_zip_vfs | |
|
2016-10-18
| ||
| 16:34 | Moved all commands to the ::practcl namespace check-in: b3592dd5a3 user: hypnotoad tags: practcl | |
Changes
Changes to practcl.tcl.
| ︙ | ︙ | |||
1952 1953 1954 1955 1956 1957 1958 |
foreach linktype [$object linktype] {
lappend links($linktype) $object
}
return $object
}
method go {} {
| | | | 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 |
foreach linktype [$object linktype] {
lappend links($linktype) $object
}
return $object
}
method go {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable links
foreach {linktype objs} [array get links] {
foreach obj $objs {
$obj go
}
}
::practcl::debug [list /[self] [self method] [self class]]
}
method code {section body} {
my variable code
::practcl::cputs code($section) $body
}
|
| ︙ | ︙ | |||
1994 1995 1996 1997 1998 1999 2000 |
foreach item [my link list subordinate] {
lappend result {*}[$item compile-products]
}
return $result
}
method generate-include-directory {} {
| | | | | | | | | | 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 |
foreach item [my link list subordinate] {
lappend result {*}[$item compile-products]
}
return $result
}
method generate-include-directory {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set result [my define get include_dir]
foreach obj [my link list product] {
foreach path [$obj generate-include-directory] {
lappend result $path
}
}
return $result
}
method generate-debug {{spaces {}}} {
set result {}
::practcl::cputs result "$spaces[list [self] [list class [info object class [self]] filename [my define get filename]] links [my link list]]"
foreach item [my link list subordinate] {
practcl::cputs result [$item generate-debug "$spaces "]
}
return $result
}
# Empty template methods
method generate-cheader {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code cfunct cstruct methods tcltype tclprocs
set result {}
if {[info exists code(header)]} {
::practcl::cputs result $code(header)
}
foreach obj [my link list product] {
# Exclude products that will generate their own C files
if {[$obj define get output_c] ne {}} continue
set dat [$obj generate-cheader]
if {[string length [string trim $dat]]} {
::practcl::cputs result "/* BEGIN [$obj define get filename] generate-cheader */"
::practcl::cputs result $dat
::practcl::cputs result "/* END [$obj define get filename] generate-cheader */"
}
}
::practcl::debug [list cfunct [info exists cfunct]]
if {[info exists cfunct]} {
foreach {funcname info} $cfunct {
if {[dict get $info public]} continue
::practcl::cputs result "[dict get $info header]\;"
}
}
::practcl::debug [list tclprocs [info exists tclprocs]]
if {[info exists tclprocs]} {
foreach {name info} $tclprocs {
if {[dict exists $info header]} {
::practcl::cputs result "[dict get $info header]\;"
}
}
}
::practcl::debug [list methods [info exists methods] [my define get cclass]]
if {[info exists methods]} {
set thisclass [my define get cclass]
foreach {name info} $methods {
if {[dict exists $info header]} {
::practcl::cputs result "[dict get $info header]\;"
}
}
# Add the initializer wrapper for the class
::practcl::cputs result "static int ${thisclass}_OO_Init(Tcl_Interp *interp)\;"
}
return $result
}
method generate-public-define {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code
set result {}
if {[info exists code(public-define)]} {
::practcl::cputs result $code(public-define)
}
set result [::practcl::_tagblock $result c [my define get filename]]
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-public-define]
}
return $result
}
method generate-public-macro {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code
set result {}
if {[info exists code(public-macro)]} {
::practcl::cputs result $code(public-macro)
}
set result [::practcl::_tagblock $result c [my define get filename]]
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-public-macro]
}
return $result
}
method generate-public-typedef {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code cstruct
set result {}
if {[info exists code(public-typedef)]} {
::practcl::cputs result $code(public-typedef)
}
if {[info exists cstruct]} {
# Add defintion for native c data structures
|
| ︙ | ︙ | |||
2116 2117 2118 2119 2120 2121 2122 |
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-public-typedef]
}
return $result
}
method generate-private-typedef {} {
| | | 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 |
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-public-typedef]
}
return $result
}
method generate-private-typedef {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code cstruct
set result {}
if {[info exists code(private-typedef)]} {
::practcl::cputs result $code(private-typedef)
}
if {[info exists cstruct]} {
# Add defintion for native c data structures
|
| ︙ | ︙ | |||
2142 2143 2144 2145 2146 2147 2148 |
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-private-typedef]
}
return $result
}
method generate-public-structure {} {
| | | 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 |
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-private-typedef]
}
return $result
}
method generate-public-structure {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code cstruct
set result {}
if {[info exists code(public-structure)]} {
::practcl::cputs result $code(public-structure)
}
if {[info exists cstruct]} {
foreach {name info} $cstruct {
|
| ︙ | ︙ | |||
2166 2167 2168 2169 2170 2171 2172 |
::practcl::cputs result [$mod generate-public-structure]
}
return $result
}
method generate-private-structure {} {
| | | 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 |
::practcl::cputs result [$mod generate-public-structure]
}
return $result
}
method generate-private-structure {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code cstruct
set result {}
if {[info exists code(private-structure)]} {
::practcl::cputs result $code(private-structure)
}
if {[info exists cstruct]} {
foreach {name info} $cstruct {
|
| ︙ | ︙ | |||
2189 2190 2191 2192 2193 2194 2195 |
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-private-structure]
}
return $result
}
method generate-public-headers {} {
| | | 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 |
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-private-structure]
}
return $result
}
method generate-public-headers {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code tcltype
set result {}
if {[info exists code(public-header)]} {
::practcl::cputs result $code(public-header)
}
if {[info exists tcltype]} {
foreach {type info} $tcltype {
|
| ︙ | ︙ | |||
2217 2218 2219 2220 2221 2222 2223 |
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-public-headers]
}
return $result
}
method generate-stub-function {} {
| | | | | | | 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 |
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-public-headers]
}
return $result
}
method generate-stub-function {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code cfunct tcltype
set result {}
foreach mod [my link list product] {
foreach {funct def} [$mod generate-stub-function] {
dict set result $funct $def
}
}
if {[info exists cfunct]} {
foreach {funcname info} $cfunct {
if {![dict get $info export]} continue
dict set result $funcname [dict get $info header]
}
}
return $result
}
method generate-public-function {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code cfunct tcltype
set result {}
if {[my define get initfunc] ne {}} {
::practcl::cputs result "int [my define get initfunc](Tcl_Interp *interp);"
}
if {[info exists cfunct]} {
foreach {funcname info} $cfunct {
if {![dict get $info public]} continue
::practcl::cputs result "[dict get $info header]\;"
}
}
set result [::practcl::_tagblock $result c [my define get filename]]
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-public-function]
}
return $result
}
method generate-public-includes {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set includes {}
foreach item [my define get public-include] {
if {$item ni $includes} {
lappend includes $item
}
}
foreach mod [my link list product] {
foreach item [$mod generate-public-includes] {
if {$item ni $includes} {
lappend includes $item
}
}
}
return $includes
}
method generate-public-verbatim {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set includes {}
foreach item [my define get public-verbatim] {
if {$item ni $includes} {
lappend includes $item
}
}
foreach mod [my link list subordinate] {
foreach item [$mod generate-public-verbatim] {
if {$item ni $includes} {
lappend includes $item
}
}
}
return $includes
}
###
# This methods generates the contents of an amalgamated .h file
# which describes the public API of this module
###
method generate-h {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set result {}
set includes [my generate-public-includes]
foreach inc $includes {
if {[string index $inc 0] ni {< \"}} {
::practcl::cputs result "#include \"$inc\""
} else {
::practcl::cputs result "#include $inc"
|
| ︙ | ︙ | |||
2350 2351 2352 2353 2354 2355 2356 |
}
###
# This methods generates the contents of an amalgamated .c file
# which implements the loader for a batch of tools
###
method generate-c {} {
| | | 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 |
}
###
# This methods generates the contents of an amalgamated .c file
# which implements the loader for a batch of tools
###
method generate-c {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set result {
/* This file was generated by practcl */
}
set includes {}
foreach mod [my link list product] {
# Signal modules to formulate final implementation
|
| ︙ | ︙ | |||
2394 2395 2396 2397 2398 2399 2400 |
set dat [my $method]
if {[string length [string trim $dat]]} {
::practcl::cputs result "/* BEGIN $method [my define get filename] */"
::practcl::cputs result $dat
::practcl::cputs result "/* END $method [my define get filename] */"
}
}
| | | | 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 |
set dat [my $method]
if {[string length [string trim $dat]]} {
::practcl::cputs result "/* BEGIN $method [my define get filename] */"
::practcl::cputs result $dat
::practcl::cputs result "/* END $method [my define get filename] */"
}
}
::practcl::debug [list /[self] [self method] [self class] -- [my define get filename] [info object class [self]]]
return $result
}
method generate-loader {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set result {}
if {[my define get initfunc] eq {}} return
::practcl::cputs result "
extern int DLLEXPORT [my define get initfunc]( Tcl_Interp *interp ) \{"
::practcl::cputs result {
/* Initialise the stubs tables. */
#ifdef USE_TCL_STUBS
|
| ︙ | ︙ | |||
2442 2443 2444 2445 2446 2447 2448 |
}
###
# This methods generates any Tcl script file
# which is required to pre-initialize the C library
###
method generate-tcl-pre {} {
| | | | 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 |
}
###
# This methods generates any Tcl script file
# which is required to pre-initialize the C library
###
method generate-tcl-pre {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set result {}
my variable code
if {[info exists code(tcl)]} {
set result [::practcl::_tagblock $code(tcl) tcl [my define get filename]]
}
if {[info exists code(tcl-pre)]} {
set result [::practcl::_tagblock $code(tcl) tcl [my define get filename]]
}
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-tcl-pre]
}
return $result
}
method generate-tcl-post {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set result {}
my variable code
if {[info exists code(tcl-post)]} {
set result [::practcl::_tagblock $code(tcl-post) tcl [my define get filename]]
}
foreach mod [my link list product] {
::practcl::cputs result [$mod generate-tcl-post]
|
| ︙ | ︙ | |||
2521 2522 2523 2524 2525 2526 2527 |
}
if {![dict exists $cstruct $name public]} {
dict set cstruct $name public 1
}
}
method generate-cinit {} {
| | | 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 |
}
if {![dict exists $cstruct $name public]} {
dict set cstruct $name public 1
}
}
method generate-cinit {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code
set result {}
if {[info exists code(cinit)]} {
::practcl::cputs result $code(cinit)
}
if {[my define get initfunc] ne {}} {
::practcl::cputs result " if([my define get initfunc](interp)!=TCL_OK) return TCL_ERROR\;"
|
| ︙ | ︙ | |||
2619 2620 2621 2622 2623 2624 2625 |
return {subordinate product dynamic}
}
###
# Populate const static data structures
###
method generate-cstruct {} {
| | | | 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 |
return {subordinate product dynamic}
}
###
# Populate const static data structures
###
method generate-cstruct {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code cstruct methods tcltype
set result {}
if {[info exists code(struct)]} {
::practcl::cputs result $code(struct)
}
foreach obj [my link list dynamic] {
# Exclude products that will generate their own C files
if {[$obj define get output_c] ne {}} continue
::practcl::cputs result [$obj generate-cstruct]
}
return $result
}
method generate-constant {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set result {}
my variable code cstruct methods tcltype
if {[info exists code(constant)]} {
::practcl::cputs result "/* [my define get filename] CONSTANT */"
::practcl::cputs result $code(constant)
}
if {[info exists cstruct]} {
|
| ︙ | ︙ | |||
2723 2724 2725 2726 2727 2728 2729 |
}
###
# Generate code that provides subroutines called by
# Tcl API methods
###
method generate-cfunct {} {
| | | 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 |
}
###
# Generate code that provides subroutines called by
# Tcl API methods
###
method generate-cfunct {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code cfunct
set result {}
if {[info exists code(funct)]} {
::practcl::cputs result $code(funct)
}
if {[info exists cfunct]} {
foreach {funcname info} $cfunct {
|
| ︙ | ︙ | |||
2750 2751 2752 2753 2754 2755 2756 |
}
###
# Generate code that provides implements Tcl API
# calls
###
method generate-cmethod {} {
| | | 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 |
}
###
# Generate code that provides implements Tcl API
# calls
###
method generate-cmethod {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
my variable code methods tclprocs
set result {}
if {[info exists code(method)]} {
::practcl::cputs result $code(method)
}
if {[info exists tclprocs]} {
|
| ︙ | ︙ | |||
2851 2852 2853 2854 2855 2856 2857 |
}
###
# Generate code that runs when the package/module is
# initialized into the interpreter
###
method generate-cinit {} {
| | | 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 |
}
###
# Generate code that runs when the package/module is
# initialized into the interpreter
###
method generate-cinit {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set result {}
my variable code methods tclprocs
if {[info exists code(nspace)]} {
::practcl::cputs result " \{\n Tcl_Namespace *modPtr;"
foreach nspace $code(nspace) {
::practcl::cputs result [string map [list @NSPACE@ $nspace] {
modPtr=Tcl_FindNamespace(interp,"@NSPACE@",NULL,TCL_NAMESPACE_ONLY);
|
| ︙ | ︙ | |||
2982 2983 2984 2985 2986 2987 2988 |
foreach {f v} $arginfo {
dict set tclprocs $name $f $v
}
dict set tclprocs $name body $body
}
method go {} {
| | | | 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 |
foreach {f v} $arginfo {
dict set tclprocs $name $f $v
}
dict set tclprocs $name body $body
}
method go {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
next
my variable methods code cstruct tclprocs
if {[info exists methods]} {
::practcl::debug [self] methods [my define get cclass]
set thisclass [my define get cclass]
foreach {name info} $methods {
# Provide a callproc
if {![dict exists $info callproc]} {
set callproc [string map {____ _ ___ _ __ _} [string map {{ } _ : _} OOMethod_${thisclass}_${name}]]
dict set methods $name callproc $callproc
} else {
|
| ︙ | ︙ | |||
3011 3012 3013 3014 3015 3016 3017 |
if {![info exists code(initfuncts)] || "${thisclass}_OO_Init" ni $code(initfuncts)} {
lappend code(initfuncts) "${thisclass}_OO_Init"
}
}
set thisnspace [my define get nspace]
if {[info exists tclprocs]} {
| | | | 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 |
if {![info exists code(initfuncts)] || "${thisclass}_OO_Init" ni $code(initfuncts)} {
lappend code(initfuncts) "${thisclass}_OO_Init"
}
}
set thisnspace [my define get nspace]
if {[info exists tclprocs]} {
::practcl::debug [self] tclprocs [dict keys $tclprocs]
foreach {name info} $tclprocs {
if {![dict exists $info callproc]} {
set callproc [string map {____ _ ___ _ __ _} [string map {{ } _ : _} TclCmd_${thisnspace}_${name}]]
dict set tclprocs $name callproc $callproc
} else {
set callproc [dict get $info callproc]
}
if {[dict exists $info body] && ![dict exists $info header]} {
dict set tclprocs $name header "static int ${callproc}(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv\[\])"
}
}
}
::practcl::debug [list /[self] [self method] [self class]]
}
# Once an object marks itself as some
# flavor of dynamic, stop trying to morph
# it into something else
method select {} {}
|
| ︙ | ︙ | |||
3112 3113 3114 3115 3116 3117 3118 |
}
if {[my define get name] eq {}} {
my define set name [file tail [file dirname $filename]]
}
if {[my define get localpath] eq {}} {
my define set localpath [my <project> define get name]_[my define get name]
}
| | | | | | 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 |
}
if {[my define get name] eq {}} {
my define set name [file tail [file dirname $filename]]
}
if {[my define get localpath] eq {}} {
my define set localpath [my <project> define get name]_[my define get name]
}
::practcl::debug [self] SOURCE $filename
my source $filename
}
method implement path {
my go
my Collate_Source $path
foreach item [my link list dynamic] {
if {[catch {$item implement $path} err]} {
puts "Skipped $item: $err"
}
}
foreach item [my link list module] {
if {[catch {$item implement $path} err]} {
puts "Skipped $item: $err"
}
}
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set filename [my define get output_c]
if {$filename eq {}} {
::practcl::debug [list /[self] [self method] [self class]]
return
}
set cout [open [file join $path [file rootname $filename].c] w]
puts $cout [subst {/*
** This file is generated by the [info script] script
** any changes will be overwritten the next time it is run
*/}]
puts $cout [my generate-c]
puts $cout [my generate-loader]
close $cout
::practcl::debug [list /[self] [self method] [self class]]
}
method linktype {} {
return {subordinate product dynamic module}
}
}
|
| ︙ | ︙ | |||
3329 3330 3331 3332 3333 3334 3335 |
package provide @PKG_NAME@ @PKG_VERSION@
}]
}
return $result
}
method go {} {
| | | 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 |
package provide @PKG_NAME@ @PKG_VERSION@
}]
}
return $result
}
method go {} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set name [my define getnull name]
if {$name eq {}} {
set name generic
my define name generic
}
if {[my define get tk] eq {@TEA_TK_EXTENSION@}} {
my define set tk 0
|
| ︙ | ︙ | |||
3374 3375 3376 3377 3378 3379 3380 |
}
my variable links
foreach {linktype objs} [array get links] {
foreach obj $objs {
$obj go
}
}
| | | 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 |
}
my variable links
foreach {linktype objs} [array get links] {
foreach obj $objs {
$obj go
}
}
::practcl::debug [list /[self] [self method] [self class] -- [my define get filename] [info object class [self]]]
}
method implement path {
my go
my Collate_Source $path
foreach item [my link list dynamic] {
if {[catch {$item implement $path} err]} {
|
| ︙ | ︙ | |||
3426 3427 3428 3429 3430 3431 3432 |
puts $tclout [my generate-tcl-loader]
puts $tclout [my generate-tcl-post]
close $tclout
}
}
method generate-decls {pkgname path} {
| | | 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 |
puts $tclout [my generate-tcl-loader]
puts $tclout [my generate-tcl-post]
close $tclout
}
}
method generate-decls {pkgname path} {
::practcl::debug [list [self] [self method] [self class] -- [my define get filename] [info object class [self]]]
set outfile [file join $path/$pkgname.decls]
###
# Build the decls file
###
set fout [open $outfile w]
puts $fout [subst {###
|
| ︙ | ︙ |