cp -a ${ODIE_SRC_DIR}/odieConfig.tcl ${LOCAL_REPO}/lib/odieConfig.tcl
	cp -a ${ODIE_SRC_DIR}/odieConfig.sh ${LOCAL_REPO}/lib/odieConfig.sh

install: sherpa
	$(SHELL) scripts/make_skel.sh
	$(SHELL) scripts/make_tcl.sh
	ODIE_BUILD_TCLSH=`autosetup/find-tclsh`
	$(ODIE_BUILD_TCLSH) scripts/make_gort.tcl
	$(SHERPA) upgrade sqlite odielib tcllib
	${ODIE_BUILD_TCLSH} build.tcl toadkit

packages: sherpa
	$(SHERPA) install odielib tcllib

upgrade:
	$(FOSSIL) update
	${ODIE_BUILD_TCLSH} scripts/upgrade.tcl
	$(ODIE_BUILD_TCLSH) scripts/make_gort.tcl
	$(SHERPA) upgrade sqlite odielib tcllib
	${ODIE_BUILD_TCLSH} build.tcl toadkit

upgrade-tcl:
	$(FOSSIL) update
	$(SHELL) scripts/make_tcl.sh
	ODIE_BUILD_TCLSH=`autosetup/find-tclsh`
	${ODIE_BUILD_TCLSH} scripts/upgrade.tcl
	$(ODIE_BUILD_TCLSH) scripts/make_gort.tcl
	$(SHERPA) upgrade sqlite odielib tcllib
	${ODIE_BUILD_TCLSH} build.tcl clean
	rm -rf tcl tk
	${ODIE_BUILD_TCLSH} build.tcl toadkit

tcl:
	$(SHELL) scripts/make_tcl.sh

rebuild:
	$(SHELL) scripts/make_distclean.sh
	$(FOSSIL) update
	$(SHELL) scripts/make_tcl.sh
	$(ODIE_BUILD_TCLSH) scripts/make_gort.tcl
	$(SHERPA) upgrade sqlite odielib tcllib
	${ODIE_BUILD_TCLSH} build.tcl toadkit

distclean:
	$(SHELL) scripts/make_distclean.sh

basekit:
	${ODIE_BUILD_TCLSH} build.tcl toadkit

sherpa: $ODIE_SANDBOX/sherpa/sherpa.tcl

gort: $ODIE_SANDBOX/gort/gort.tcl

$ODIE_SANDBOX/sherpa/sherpa.tcl:
	$(ODIE_BUILD_TCLSH) scripts/make_gort.tcl

$ODIE_SANDBOX/gort/gort.tcl:
	$(ODIE_BUILD_TCLSH) scripts/make_gort.tcl

$(ODIE_MKHDR):
	$(CC) -o mkhdr.o scripts/mkhdr.c
	$(CC) mkhdr.o -o mkhdr${EXE_SUFFIX}
	cp -f mkhdr@EXE@ $(ODIE_MKHDR)

mkhdr: $(ODIE_MKHDR)

foreach {program required domake} {
  zip 	 1 0
  unzip  1 0
  tar    1 0
  git    0 1
  strip  0 0
  mkhdr  0 1
  gort 0 1
} {
  if {$required} {
    set exename [lindex [find-an-executable -required $program] 0]
  } else {
    set exename [lindex [find-an-executable $program] 0]
  }
  if {$domake && $exename eq {}} {

# @synopsis:
#
# ODIE modules adds teacup platform data and integration with
# gort
#
use system codebale
# Build procs for this modules

options {
nodots => "Suppress dots in version numbers in lib names"
pkgdir: => "Where to install the package (default $prefix/lib)"

# Initialize our picture of the world
###
array set odie_tcl {
  config_flags {}
  version 8.6
  major_version 8
  minor_version 6
  patch_level .5
  fossil_branch release
}
array set odie_tk {
  config_flags {}
  version 8.6
  major_version 8
  minor_version 6
  patch_level .5
  fossil_branch release
}
array set odie {
  exe_suffix {}
  platform unix
  tea_platform_dir unix
  tcl_platform_dir unix

    set ::odie(ld_flags) "-static-libgcc -static-libstdc++"
  }
  *win32* - *WIN32* {
    ###
    # With visual studio, 64 bit should be assumed
    # but is otherwise to taste
    ###
    set ::odie(windows) 1
    set ::odie(os) windows

  } 
}

###
# Build information about the local tools

set ::force_check 0
###
# Under MSYS/Cygwin transform the Cygwinized paths
# pack into proper names for Windows
###
foreach path {
  sandbox download src_dir tcl_shell wish_shell build_tclsh
  fossil git zip unzip lib local_repo
} {
  if {[info exists ::odie($path)]} {
    set ::odie_build($path) [::realpath $::odie($path)]
  }
}

###
# script to build a tclkit
###




#####





# Define procedures



#####


namespace eval ::practcl {}
proc ::cat fname {
    set fname [open $fname r]
    set data [read $fname]
    close $fname
    return $data
}

proc ::practcl::localtools {} {
  
}

proc ::practcl::_isdirectory name {
  return [file isdirectory $name]
}
###
# topic: ebd68484cb7f18cad38beaab3cf574e2de5702ea
###
proc ::practcl::_istcl name {
  return [string match *.tcl $name]
}

###
# topic: 2e481bd24d970304a1dd0acad3d75198b56c122e
###
proc ::practcl::_istm name {
  return [string match *.tm $name]
}

###
# Return true if the pkgindex file contains
# any statement other than "package ifneeded"
# and/or if any package ifneeded loads a DLL
###
proc ::practcl::_pkgindex_directory {path} {
  set buffer {}
  set pkgidxfile [file join $path pkgIndex.tcl]
  if {![file exists $pkgidxfile]} {
    # No pkgIndex file, read the source
    foreach file [glob -nocomplain $path/*.tm] {
      set file [file normalize $file]
      set fname [file rootname [file tail $file]]
      ###
      # We used to be able to ... Assume the package is correct in the filename
      # No hunt for a "package provides"
      ###
      set package [lindex [split $fname -] 0]
      set version [lindex [split $fname -] 1]
      ###
      # Read the file, and override assumptions as needed
      ###
      set fin [open $file r]
      set dat [read $fin]
      close $fin
      # Look for a teapot style Package statement
      foreach line [split $dat \n] {
        set line [string trim $line]
        if { [string range $line 0 9] != "# Package " } continue
        set package [lindex $line 2]
        set version [lindex $line 3]
        break
      }
      # Look for a package provide statement
      foreach line [split $dat \n] {
        set line [string trim $line]              
        if { [string range $line 0 14] != "package provide" } continue
        set package [lindex $line 2]
        set version [lindex $line 3]
        break
      }
      append buffer "package ifneeded $package $version \[list source \[file join \$dir [file tail $file]\]\]" \n
    }
    foreach file [glob -nocomplain $path/*.tcl] {
      if { [file tail $file] == "version_info.tcl" } continue
      set fin [open $file r]
      set dat [read $fin]
      close $fin
      if {![regexp "package provide" $dat]} continue
      set fname [file rootname [file tail $file]]
      # Look for a package provide statement
      foreach line [split $dat \n] {
        set line [string trim $line]              
        if { [string range $line 0 14] != "package provide" } continue
        set package [lindex $line 2]
        set version [lindex $line 3]
        if {[string index $package 0] in "\$ \["} continue
        if {[string index $version 0] in "\$ \["} continue
        append buffer "package ifneeded $package $version \[list source \[file join \$dir [file tail $file]\]\]" \n
        break
      }
    }
    return $buffer
  }
  set fin [open $pkgidxfile r]
  set dat [read $fin]
  close $fin
  set thisline {}
  foreach line [split $dat \n] {
    append thisline $line \n
    if {![info complete $thisline]} continue
    set line [string trim $line]
    if {[string length $line]==0} {
      set thisline {} ; continue
    }
    if {[string index $line 0] eq "#"} {
      set thisline {} ; continue
    }
    try {
      # Ignore contditionals
      if {[regexp "if.*catch.*package.*Tcl.*return" $thisline]} continue
      if {[regexp "if.*package.*vsatisfies.*package.*provide.*return" $thisline]} continue
      if {![regexp "package.*ifneeded" $thisline]} {
        # This package index contains arbitrary code
        # source instead of trying to add it to the master
        # package index
        return {source [file join $dir pkgIndex.tcl]} 
      }
      append buffer $thisline \n
    } on error {err opts} {
      puts ***
      puts "GOOF: $pkgidxfile"
      puts $line
      puts $err
      puts [dict get $opts -errorinfo]
      puts ***
    } finally {
      set thisline {}
    }
  }
  return $buffer
}

###
# Index all paths given as though they will end up in the same
# virtual file system
###
proc ::practcl::pkgindex_path args {
  set stack {}
  set buffer {
lappend ::PATHSTACK $dir
  }
  foreach base $args {
    set i    [string length  $base]
    # Build a list of all of the paths
    set paths [fileutil::find $base ::practcl::_isdirectory]
    foreach path $paths {
      if {$path eq $base} continue
      set path_indexed($path) 0
    }
    set path_index([file join $base boot tcl]) 1
    set path_index([file join $base boot tk]) 1
  
    foreach path $paths {
      set thisdir [::fileutil::relative $base $path]
      set idxbuf [::practcl::_pkgindex_directory $path]
      if {[string length $idxbuf]} {
        incr path_indexed($path)
        append buffer "set dir \[file join \[lindex \$::PATHSTACK end\] $thisdir\]" \n
        append buffer [string trimright $idxbuf] \n
      } 
    }
  }
  append buffer {
set dir [lindex $::PATHSTACK end]  
set ::PATHSTACK [lrange $::PATHSTACK 0 end-1]
}
  return $buffer
}

proc read_Config.sh {filename} {
  set fin [open $filename r]
  set result {}
  while {[gets $fin line] >= 0} {
    set line [string trim $line]

proc ::domake {args} {
  puts [list make {*}$args]
  exec make {*}$args >&@ stdout
}

proc ::COMPILE {which cfile {extras {}}} {
  set objfile [file normalize [file join $::PWD build [file tail [file dirname $cfile]]_[file rootname [file tail $cfile]].o]]
  lappend ::KIT(${which}_OBJS) $objfile
  if {[file exists $objfile] && [file mtime $objfile] > [file mtime $cfile]} return
  lappend cmd  $::KIT(cc) {*}$::KIT(cflags_optimize) {*}$::KIT(shlib_cflags) {*}$::KIT(cflags_warning) {*}$::KIT(extra_cflags) {*}$::KIT(defs) {*}$extras
  foreach path $::KIT(INCLUDES) {
    lappend cmd -I./[fileutil::relative $::PWD $path]
  }
  lappend cmd {*}$::KIT(EXTRA_CFLAGS)
  lappend cmd -c [fileutil::relative $::PWD $cfile] -o $objfile
  puts [list [file tail $cfile] -> [file tail $objfile]]
  puts $cmd
  exec {*}$cmd >&@ stdout
}

proc ::copyDir {d1 d2} {
  #puts [list $d1 -> $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]} {
      copyDir $f [file join $d2 $ftail]
    } elseif {[file isfile $f]} {
      file copy -force $f [file join $d2 $ftail]
    }
  }
}

proc ::practcl::wrap {PWD name vfspath args} {
  cd $PWD
  if {![file exists $vfspath]} {
    file mkdir $vfspath
  }
  package ifneeded zipfile::mkzip 1.2 [list source [file join $::HERE scripts mkzip.tcl]]
  package require zipfile::mkzip
  set fout [open [file join $vfspath packages.tcl] w]
  set buffer [::practcl::pkgindex_path $::KIT(BASEVFS) $vfspath]
  puts $fout $buffer
  close $fout
  copyDir $::KIT(BASEVFS) $vfspath
  foreach arg $args {
     copyDir $arg $vfspath
  }
  ::zipfile::mkzip::mkzip ${name}$::KIT(EXEEXT) -runtime $::TARGET(tclkit_bare) -directory $vfspath
  file attributes ${name}$::KIT(EXEEXT) -permissions a+x
}

#########################################
#
# BUILD THE INTERPRETER ENVIRONMENT
#
#########################################

set HERE [file dirname [file normalize [info script]]]
set PWD [pwd]

lappend auto_path [file normalize [file join $HERE .. tcllib modules]]
lappend auto_path [file normalize [file join $HERE .. odielib modules]]
#package ifneeded zipfile::mkzip 1.2 [list source [file join $::HERE scripts mkzip.tcl]]

package require fileutil

#########################################
#
# BEGIN THE KITBUILDING PROCESS HERE
#
#########################################
set _search_paths {{$PWD} {$PWD ..}}
if {![file exists [file join $::HERE odieConfig.tcl]]} {
  # Build the local toolset
  cd $HERE
  exec [info nameofexecutable] [file join $HERE autosetup autosetup]
  cd $PWD
}
puts "AUTOPATH (276): $::auto_path"
source [file join $::HERE odieConfig.tcl]
set ::KIT(platform) ::odie(platform)
set ::KIT(ORIG_TCL_SRC_DIR) $::odie_tcl(src_dir)
set ::KIT(ORIG_TK_SRC_DIR) $::odie_tk(src_dir)
set ::KIT(TCL_BUILD_OPTS) $::odie_tcl(config_flags)
set ::KIT(TK_BUILD_OPTS) $::odie_tk(config_flags)
set ::KIT(HOST) $::odie(host)
set ::KIT(TARGET) $::odie(target)
set ::KIT(TCL_VERSION) $::odie_tcl(version)
set ::KIT(TK_VERSION) $::odie_tk(version)
set ::KIT(TCL_PATCH_LEVEL) $::odie_tcl(patch_level)
set ::KIT(TK_PATCH_LEVEL) $::odie_tk(patch_level)

if {[file exists [file join $PWD project.rc]]} {
  source [file join $PWD project.rc]
  set ::KIT(platform) $::project(TEA_PLATFORM)
  set ::KIT(ORIG_TCL_SRC_DIR) $::project(TCL_SRC_DIR)
  set ::KIT(ORIG_TK_SRC_DIR) $::project(TK_SRC_DIR)
  set ::KIT(TARGET) $::project(TEA_PLATFORM)
  set ::KIT(TCL_VERSION) $::project(TCL_VERSION)
  set ::KIT(TK_VERSION) $::project(TK_VERSION)  
  set ::KIT(TCL_PATCH_LEVEL) $::project(TCL_PATCH_LEVEL)
  set ::KIT(TK_PATCH_LEVEL) $::project(TCL_PATCH_LEVEL)
  lappend _search_paths {[file dirname $::project(srcdir)]}
}
lappend _search_paths $::odie(sandbox)


array set build {
  tcl 0
  tk  0
  packages 0
  basekitvfs 0
  toadkit.rc 0
  toadkit 0
  tclkit_bare 0
  libtoadkit.a 0
}

###
# Begin processing our arguments
###
set COMMAND [lindex $argv 0]
switch $COMMAND {
  localtcl {
    
  }
  toadkit {
    set build(toadkit) 1
  }
  basekit {
    set build(toadkit) 1
  }
  wrap {
    
  }
  clean {
  }
  default {
    error "Unknown command $COMMAND. Valid: clean tcl toadkit wrap"
  }
}

if { $::KIT(platform) eq "windows" } {
  set ::KIT(EXEEXT) .exe
  set ::KIT(platform_src_dir) win
  set USEMSVC [info exists env(VisualStudioVersion)]
} else {
  set ::KIT(EXEEXT) {}
  set ::KIT(platform_src_dir) unix
  set USEMSVC 0
}
set ::KIT(PKGPREFIX) /zvfs

foreach dpath $_search_paths {
  set path [file normalize [file join {*}[subst $dpath] toadkit$::KIT(TCL_VERSION)$::KIT(TCL_PATCH_LEVEL)]]
  set ::KIT(TCLSRCDIR)  [file join $path tcl]
  set ::KIT(TKSRCDIR)   [file join $path tk]
  set ::KIT(PKGROOT)    [file join $path pkg]
  set ::KIT(BASEVFS)    [file join $path vfs]
  if {[file exists $::KIT(TCLSRCDIR)]} {
    break
  }
}


###
# Sort out our various build products
###
set _TclSrcDir [file join $::KIT(TCLSRCDIR) $::KIT(platform_src_dir)]
set _TkSrcDir  [file join $::KIT(TKSRCDIR) $::KIT(platform_src_dir)]

set ::TARGET(tclConfig.sh) [file join $_TclSrcDir tclConfig.sh]
set ::TARGET(tkConfig.sh)  [file join $_TkSrcDir tkConfig.sh]
set ::TARGET(libtoadkit.a) [file join $PWD libtoadkit.a]
set ::TARGET(tclkit_bare)  [file join $PWD tclkit_bare$::KIT(EXEEXT)]
set ::TARGET(toadkit.rc)   [file join $PWD toadkit.rc]


if {![file exists $::TARGET(tclkit_bare)]} {
  set build(tclkit_bare) 1
}
if {![file exists $::TARGET(tclConfig.sh)]} {
  set build(tcl) 1
  set build(tk) 1
}
if {![file exists $::TARGET(tkConfig.sh)]} {

  set build(tk) 1
}
if {![file exists $::TARGET(libtoadkit.a)]} {
  set build(libtoadkit.a) 1
}
if {![file exists $::KIT(PKGROOT)]} {
  set build(packages) 1
}
if {![file exists $::KIT(BASEVFS)]} {
  set build(basekitvfs) 1
}
if {$build(tcl) || $build(tk) || $build(toadkit)} {
  set build(packages) 1
  set build(basekitvfs) 1
  set build(toadkit.rc) 1
  set build(tclkit_bare) 1

  set build(libtoadkit.a) 1
}
if {$build(libtoadkit.a)} {
  set build(tclkit_bare) 1
}
if {$build(packages)} {
  set build(basekitvfs) 1
}
if {![file exists $::TARGET(toadkit.rc)]} {
  set build(toadkit.rc) 1
}
file mkdir build


puts "***
::KIT(TCLSRCDIR):  [file exists $::KIT(TCLSRCDIR)] $::KIT(TCLSRCDIR)
::KIT(TKSRCDIR):   [file exists $::KIT(TKSRCDIR)] $::KIT(TKSRCDIR)
::KIT(PKGROOT):    [file exists $::KIT(PKGROOT)] $::KIT(PKGROOT)
::KIT(BASEVFS):    [file exists $::KIT(BASEVFS)] $::KIT(BASEVFS)
toadkit.rc:      [file exists $::TARGET(toadkit.rc)] $::TARGET(toadkit.rc)
***"
parray build

if {$COMMAND eq "clean"} {
  file delete -force $path
  file delete -force build/
  foreach file [glob -nocomplain *.a] {
    file delete $file
  }
  exit
}


if {$build(tcl)} {
  file mkdir build
  file mkdir [file join $::KIT(BASEVFS) boot]
  ###
  # Build a starter VFS for both Tcl and wish
  ###
  if {![file exists $::KIT(TCLSRCDIR)]} {
    copyDir $::KIT(ORIG_TCL_SRC_DIR) $::KIT(TCLSRCDIR)
    cd $_TclSrcDir
    catch {domake distclean}
  }
  if {$USEMSVC} {
    puts "BUILDING Static Tcl"
    cd $_TclSrcDir
    doexec nmake -f makefile.vc INSTALLDIR=$::KIT(PKGROOT) release
    doexec nmake -f makefile.vc INSTALLDIR=$::KIT(PKGROOT) install
    cd $PWD
  } else {
    if {![file exists $::TARGET(tclConfig.sh)]} {
      puts "BUILDING Static Tcl"
      cd $_TclSrcDir
      set opts {}
      if {$::KIT(HOST) != $::KIT(TARGET)} {
        lappend opts --host=$::KIT(TARGET)
      }
      lappend opts {*}$::KIT(TCL_BUILD_OPTS) --prefix=$::KIT(PKGPREFIX) --exec_prefix=$::KIT(PKGPREFIX) --with-tzdata --enable-shared=no
      puts ***
      puts "CONFIGURE {*}opts"
      puts ***
      doexec sh configure {*}$opts
      domake binaries
      domake packages
      cd $PWD
    }
  }
}
if {$build(tk)} {
  if {![file exists $::KIT(TKSRCDIR)]} {
    copyDir $::KIT(ORIG_TK_SRC_DIR) $::KIT(TKSRCDIR)
    cd [file join $_TkSrcDir]
    catch {domake distclean}
  }
  if {$USEMSVC} {
    cd $_TkSrcDir
    puts "BUILD TK"
    doexec nmake -f makefile.vc TCLDIR=[file nativename $::KIT(TCLSRCDIR)] INSTALLDIR=$::KIT(PKGROOT) release
    doexec nmake -f makefile.vc TCLDIR=[file nativename $::KIT(TCLSRCDIR)] INSTALLDIR=$::KIT(PKGROOT) install
    cd $PWD
  } else {
    if {![file exists $::TARGET(tkConfig.sh)]} {
      puts "BUILD TK"
      set opts {}
      cd $_TkSrcDir
      if {$::KIT(HOST) != $::KIT(TARGET)} {
        lappend opts --host=$::KIT(TARGET)
      }
      lappend opts {*}$::KIT(TK_BUILD_OPTS) --with-tcl=$_TclSrcDir --enable-shared=yes
      puts ***
      puts "CONFIGURE {*}opts"
      puts ***
      doexec sh configure {*}$opts
      domake binaries




      cd $PWD
    }
  }
}

if {$build(toadkit.rc)} {
  set ::KIT(OBJS) {}
  set ::KIT(INCLUDES) {}

  ###
  # Read tclConfig.sh and tkConfig.sh
  ###
  foreach {array pre file} [list ::TCL tcl $::TARGET(tclConfig.sh) ::TK tk $::TARGET(tkConfig.sh)] {
    set l [expr {[string length $pre]+1}]
    foreach {field dat} [read_Config.sh $file] {
      set field [string tolower $field]
      if {[string match ${pre}_* $field]} {
        set field [string range $field $l end]
      }
      set ${array}($field) $dat
      if {[info exists ::KIT($field)]} {
        if {$::KIT($field) ne $dat} {
          unset ::KIT($field)
        }
      } else {
        set ::KIT($field) $dat
      }
    }
  }

  ###
  # Add/synthesize bits
  ###
  lappend ::KIT(INCLUDES) [file join $::KIT(TKSRCDIR) generic]
  lappend ::KIT(INCLUDES) [file join $::KIT(TKSRCDIR) $::KIT(platform_src_dir)]
  lappend ::KIT(INCLUDES) [file join $::KIT(TKSRCDIR) bitmaps]
  lappend ::KIT(INCLUDES) [file join $::KIT(TKSRCDIR) xlib]
  
  lappend ::KIT(INCLUDES) [file join $::KIT(TCLSRCDIR) generic]
  lappend ::KIT(INCLUDES) [file join $::KIT(TCLSRCDIR) $::KIT(platform_src_dir)]
  #lappend ::KIT(INCLUDES) [file join $$::KIT(TCLSRCDIR) compat]
  lappend ::KIT(INCLUDES) [file join $::KIT(TCLSRCDIR) compat zlib]
  
  lappend ::KIT(INCLUDES) [file join $::HERE generic]
  lappend ::KIT(INCLUDES) [file join $::HERE $::KIT(platform_src_dir)]
  
  if { $::KIT(platform) eq "windows" } {
    set ::KIT(EXEEXT) .exe
    set ::KIT(LDFLAGS_CONSOLE) {-mconsole -pipe -static-libgcc}
    set ::KIT(LDFLAGS_WINDOW) {-mwindows -pipe -static-libgcc}
    set ::KIT(EXTRA_CFLAGS) {-DTCL_TOMMATH -DMP_PREC=4 -DUNICODE -D_UNICODE -DBUILD_tcl -DBUILD_tk -DBUILD_ttk -DSTATIC_BUILD}

    if {[file exists [file join $PWD tclkit.rc]]} {
      set RCSRC [file join $PWD tclkit.rc]
    } else {
      set RCSRC [file join $_TkSrcDir rc wish.rc]
    }
    doexec windres -o [file join $PWD tclkit.res.o] -DSTATIC_BUILD \
      --include [file join $::KIT(TCLSRCDIR) generic] --include [file join $::KIT(TKSRCDIR) generic] \
      --include $_TkSrcDir \
      --include [file join $_TkSrcDir rc] $RCSRC

    lappend ::KIT(TCLSHELL_OBJS) [file join $PWD tclkit.res.o] 
    lappend ::KIT(WISHSHELL_OBJS) [file join $PWD tclkit.res.o]
    lappend ::KIT(INCLUDES) [file join $_TkSrcDir rc]
  } else {
    set ::KIT(EXEEXT) {}
    set ::KIT(LDFLAGS_CONSOLE) {}
    set ::KIT(LDFLAGS_WINDOW) {}
    set ::KIT(EXTRA_CFLAGS) {-DTCL_TOMMATH -DMP_PREC=4 -DBUILD_tk -DBUILD_ttk}
  }

  set ::KIT(LIBS) {}



  set ::KIT(defs) $::TK(defs)
  
  set fout [open $::TARGET(toadkit.rc) w]
  puts $fout "array set ::TCL \{"
  foreach {field value} [lsort -stride 2 [array get ::TCL]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"
  puts $fout "array set ::TK \{"
  foreach {field value} [lsort -stride 2 [array get ::TK]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"
  puts $fout "array set ::TARGET \{"
  foreach {field value} [lsort -stride 2 [array get ::TARGET]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"
  puts $fout "array set ::KIT \{"
  foreach {field value} [lsort -stride 2 [array get ::KIT]] {
    puts $fout "  [list $field $value]"
  }
  puts $fout "\}"
  close $fout
} else {
  source $::TARGET(toadkit.rc)
}


if {$build(libtoadkit.a)} {
  ###
  # Compile our resident static C library
  ###
  cd $PWD
  if {[file exists $::TARGET(libtoadkit.a)]} {
    file delete $::TARGET(libtoadkit.a)
  }
  ###
  # Rig ourselves to statically build the bits of
  # zlib we need
  ###
  set cdir [file join $::KIT(TCLSRCDIR) compat zlib]
  foreach file {
    adler32.c compress.c crc32.c
    deflate.c infback.c inffast.c
    inflate.c inftrees.c trees.c
    uncompr.c zutil.c
  } {
    COMPILE LIBTOADKIT [file join $cdir $file]
  }
  
  set cdir [file join $::HERE generic]
  foreach file {
    password.c rc4.c tclkit_init.c zvfs.c zvfsboot.c
  } {
    COMPILE LIBTOADKIT [file join $cdir $file]
  }
  
  set cdir [file join $::HERE $::KIT(platform_src_dir)]
  if { $::KIT(platform) eq "windows" } {
    # tkwinico.c tlink32.c
    foreach file {
      tclsh_packages.c
    } {
      COMPILE LIBTOADKIT [file join $cdir $file]
    }



    COMPILE TCLSHELL [file join $_TclSrcDir tclAppInit.c] [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
    COMPILE WISHSHELL [file join $_TkSrcDir winMain.c] [list -DTK_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTK_LOCAL_APPINIT=Toadkit_AppInit]
    lappend ::KIT(LIBTOADKIT_OBJS) [file join $_TclSrcDir libtclstub86.a]
  } else {
    foreach file {
      tclsh_packages.c
    } {
      COMPILE LIBTOADKIT [file join $cdir $file]
    }
    COMPILE TCLSHELL [file join $_TclSrcDir tclAppInit.c] [list -DTCL_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTCL_LOCAL_APPINIT=Toadkit_AppInit]
    COMPILE WISHSHELL [file join $_TkSrcDir tkAppInit.c] [list -DTK_LOCAL_MAIN_HOOK=Toadkit_MainHook -DTK_LOCAL_APPINIT=Toadkit_AppInit]

    lappend ::KIT(LIBTOADKIT_OBJS) [file join $_TclSrcDir libtclstub8.6.a]
  }
  ###
  # Link together our executable
  ###
  doexec ar cr $::TARGET(libtoadkit.a) {*}$::KIT(LIBTOADKIT_OBJS)
  doexec ranlib $::TARGET(libtoadkit.a)
}









if {$build(packages)} {
  cd $PWD



  if {[file exists $::KIT(PKGROOT)]} {
    file delete -force $::KIT(PKGROOT)
  }
  set pkg_paths [glob [file join $::KIT(TCLSRCDIR) pkgs *]]
  foreach pkgpath $pkg_paths {
    if {[string range [file tail $pkgpath] 0 3] eq "itcl"} continue
    if {![file isdirectory $pkgpath]} continue
    cd $pkgpath

    if {![file exists [file join $pkgpath Makefile]]} {
      if {[file exists [file join $pkgpath Makefile.in]]} {
        doexec sh configure --with-tcl=$_TclSrcDir --with-tclinclude=[file join $::KIT(TCLSRCDIR) generic] --with-tzdata --enable-shared --enable-threads
      } else {
        continue
      }
    }
    puts "INSTALLING to VFS [file tail $pkgpath]"
    domake install DESTDIR=$::KIT(PKGROOT)
  }
}

if {$build(tclkit_bare)} {
  cd $PWD
  # Build a Tcl-only shell
  set cmd [list $::KIT(cc)  {*}$::KIT(cflags_optimize) {*}$::KIT(shlib_cflags)]
  lappend cmd {*}$::KIT(TCLSHELL_OBJS)
  foreach item [glob ${_TclSrcDir}/*.a] {
    lappend cmd $item
  }
  lappend cmd $::TARGET(libtoadkit.a) {*}$::TCL(libs)
  lappend cmd -o $::TARGET(tclkit_bare) {*}$::KIT(LDFLAGS_CONSOLE)
  doexec {*}$cmd
}
if {$build(basekitvfs)} {
  cd $PWD
  if {[file exists $::KIT(BASEVFS)]} {
    file delete -force $::KIT(BASEVFS)
  }

  puts "***
*** BASE KIT VFS PACKAGES
***"
  puts [list COPY [file join $::KIT(PKGROOT) [string trimleft $::KIT(PKGPREFIX) /] lib]]
  copyDir [file join $::KIT(PKGROOT) [string trimleft $::KIT(PKGPREFIX) /] lib] [file join $::KIT(BASEVFS) pkgs]
  
  copyDir [file join $::KIT(TCLSRCDIR) library] [file join $::KIT(BASEVFS) boot tcl]
  if { $::KIT(platform) eq "windows" } {
    set ddedll [glob -nocomplain [file join $_TclSrcDir tcldde*.dll]]
    if {$ddedll != {}} {
      file copy $ddedll [file join $::KIT(BASEVFS) boot tcl dde]
    }
    set regdll [glob -nocomplain [file join $_TclSrcDir tclreg*.dll]]
    if {$regdll != {}} {
      file copy $regdll [file join $::KIT(BASEVFS) boot tcl reg]
    }
  } else {
    file delete -force [file join $::KIT(BASEVFS) boot tcl dde]
    file delete -force [file join $::KIT(BASEVFS) boot tcl reg]
  }
  
  copyDir [file join $::KIT(TKSRCDIR) library] $::KIT(BASEVFS)/boot/tk
  if { $::KIT(platform) eq "windows" } {
    set dllsrc [file join $_TkSrcDir [string trim $::TK(dll_file) \"]]
  } else {
    set dllsrc [file join $_TkSrcDir [string trim $::TK(lib_file) \"]]
  }
  file copy -force $dllsrc [file join $::KIT(BASEVFS) boot tk]
  set fout [open [file join $::KIT(BASEVFS) boot tk pkgIndex.tcl] w]







  set map [list @TKVERSION@ $::TK(version)$::TK(patch_level)]

  if { $::KIT(platform) eq "windows" } {
    lappend map @TKDLL@ [string trim $::TK(dll_file) \"]
  } else {
    lappend map @TKDLL@ [string trim $::TK(lib_file) \"]
  }


  puts $fout [string map $map {
package ifneeded Tk @TKVERSION@ [list load $::tk_library/@TKDLL@ Tk]
  }]
  close $fout
}


if {$COMMAND eq "toadkit"} {
  ::practcl::wrap $::PWD toadkit toadkit-vfs





}

if {$COMMAND eq "wrap"} {
  puts "WRAP {*}[lrange $argv 1 end]"


  ::practcl::wrap $::PWD {*}[lrange $argv 1 end]





}

  return TCL_OK;
}

/*
** Destructor for codec.
*/
static void CodecDestructor(void *pCodec){
  printf("CODE DESTRUCTOR (shell)\n");
  Tcl_Free((char *)pCodec);
  printf("/CODE DESTRUCTOR (shell)\n");
}

/*
** Usage:   rc4  NAME  PASSWORD
**
** Create a new rc4 codec called NAME and initialized using PASSWORD.
*/

  return code;
}

/*
** Initialize the rc4 codec subsystem.
*/
DLLEXPORT int Rc4_Init(Tcl_Interp *interp){
  #ifdef USE_TCL_STUBS
  if (Tcl_InitStubs(interp, "8.5", 0)==NULL) {
    return TCL_ERROR;
  }
  #endif
  Tcl_CreateObjCommand(interp, "rc4", Rc4ObjCmd, 0, 0);
  Tcl_CreateObjCommand(interp, "rc4seed", Rc4SeedObjCmd, 0, 0);
  Tcl_CreateObjCommand(interp, "rc4encrypt", Rc4EncryptObjCmd, 0, 0);
  Tcl_CreateObjCommand(interp, "rc4decrypt", Rc4DecryptObjCmd, 0, 0);
  Tcl_CreateObjCommand(interp, "source_encrypt", Rc4EncryptSourceObjCmd, 0, 0);
  //Tcl_CreateObjCommand(interp, "source_decrypt", Rc4DecryptSourceObjCmd, 0, 0);
  Tcl_CreateObjCommand(interp, "eval_decrypt", Rc4DecryptEvalObjCmd, 0, 0);
  Tcl_StaticPackage(interp, "rc4", "2.0", 0);

  return TCL_OK;
}

      Tcl_DStringAppendElement(&preinit,vfsmountpoint);
      Tcl_DStringAppend(&preinit,"\nset ::SRCDIR ",-1);
      Tcl_DStringAppendElement(&preinit,vfsmountpoint);
      
      if(Tcl_FSAccess(vfstcllib,F_OK)==0) {
        Tcl_DStringAppend(&preinit,"\nset tcl_library ",-1);
        Tcl_DStringAppendElement(&preinit,Tcl_GetString(vfstcllib));
        Tcl_DStringAppend(&preinit,"\nset auto_path {}",-1);
      }
      if(Tcl_FSAccess(vfstklib,F_OK)==0) {
        Tcl_DStringAppend(&preinit,"\nset tk_library ",-1);
        Tcl_DStringAppendElement(&preinit,Tcl_GetString(vfstklib));
      }
      Tcl_DStringAppend(&preinit,"\nif {[file exists [file join $::SRCDIR packages.tcl]]} \{",-1);
      Tcl_DStringAppend(&preinit,"\n  #In a wrapped exe, we don't go out to the environment",-1);
      Tcl_DStringAppend(&preinit,"\n  set auto_path {}",-1);
      Tcl_DStringAppend(&preinit,"\n  set dir $::SRCDIR",-1);
      Tcl_DStringAppend(&preinit,"\n  source [file join $::SRCDIR packages.tcl]",-1);
      Tcl_DStringAppend(&preinit,"\n\}",-1);
      
      vfspreinit=Tcl_NewStringObj(Tcl_DStringValue(&preinit),-1);
      /* NOTE: We never decr this refcount, lest the contents of the script be deallocated */
      Tcl_IncrRefCount(vfspreinit);
      TclSetPreInitScript(Tcl_GetString(vfspreinit));

      Tcl_DecrRefCount(vfsinitscript);

MKHDR=@MKHDR_PROG@
ZIP=@ZIP_PROG@
UNZIP=@UNZIP_PROG@

ODIE_RM=${ODIE_BUILD_TCLSH}
ODIE_RM+=${ODIE_SRC_DIR}/scripts/rmdir.tcl
SHERPA=${ODIE_BUILD_TCLSH}
SHERPA+=@ODIE_SANDBOX_PATH@/gort/gort.tcl
GORT=${ODIE_BUILD_TCLSH}
GORT+=@ODIE_SANDBOX_PATH@/gort/gort.tcl
KETTLE=${ODIE_BUILD_TCLSH}
KETTLE+=${exec_prefix}/bin/kettle

###
# Bits generated by autosetup
###

  fossil       "@FOSSIL_PROG@"
  tcl_shell    "@TCLSH_PROG@"
  wish_shell   "@WISH_PROG@"
  zzetup       "${exec_prefix}/bin/zzipsetupstub@EXEEXT@"
  wish_kit     "@TKKIT_PROG@"
  tcl_kit      "@TCLKIT_PROG@"
  toad_kit     "@TOADKIT_PROG@"
  gort         "@ODIE_BUILD_TCLSH@ @ODIE_SANDBOX_PATH@/gort/gort.tcl"
  sherpa       "@ODIE_BUILD_TCLSH@ @ODIE_SANDBOX_PATH@/gort/gort.tcl"
  kettle       "${exec_prefix}/bin/kettle"
  zip_kit      "${exec_prefix}/bin/zipkit.zip"
  lib          "$prefix/lib"
  rc           "@RC@"
  res          "@RES@"
  tk_res       "@TK_RES@"
  vfs_cp       "@VFS_CP@"

  core.tcl formatting.tcl getopt.tcl misc.tcl
} {
  source [file join $::autosetup(libdir) $file]
}

proc ::noop args {}

namespace eval ::gort_bootstrap {}

proc ::gort_bootstrap::download_fossil {pkg} {
  variable distribution
  set PKG_SRCPATH [sandbox_path $pkg]
  set fosdb [fossil_db $pkg]
  if {![file exists $fosdb]} {
    puts "Fossil clone $pkg"
    set fossil_url {}
    if {[dict exists $distribution $pkg fossil_url]} {

      doexec $::odie(fossil) update [dict get $distribution $pkg fossil_branch]
  } else {
      doexec $::odie(fossil) update
  }
  return ${PKG_SRCPATH}
}

proc ::gort_bootstrap::fossil_db pkg {
  if {[file exists [file join $::odie(download) $pkg.fossil]]} {
    return [file join $::odie(download) $pkg.fossil]
  }
  return [file join $::odie(download) $pkg.fos]
}


proc ::gort_bootstrap::sandbox_path pkg {
  return [file join $::odie(sandbox) $pkg]
}

proc ::gort_bootstrap::build_gnumake {pkg action} {
  puts "BUILD GNUMAKE $pkg $action"
  if {$action eq "install"} {
    set PKG_SRCPATH [sandbox_path $pkg]
    cd ${PKG_SRCPATH}
    doexec $::odie(fossil) update
    set args [list  --prefix=$::odie(local_repo)]
    if {$::odie(host) != $::odie(target)} {

    } err] {
	puts "Died on $err"
	exit 1
    }
  }
}

proc ::gort_bootstrap::build_sak {pkg action} {
  if {$action eq "install"} {
    set PKG_SRCPATH [sandbox_path $pkg]
    doexec $::odie(build_tclsh) [file join $PKG_SRCPATH installer.tcl] \
		-app-path $::odie(prefix)/bin -pkg-path $::odie(prefix)/lib/$pkg \
                -no-examples -no-nroff -no-html \
                -no-wait -no-gui
  }
}

proc ::gort_bootstrap::build_kettle {pkg action} {
  set PKG_SRCPATH [sandbox_path $pkg]
  if {$pkg eq "kettle"} {
    doexec $::odie(build_tclsh) [file join $PKG_SRCPATH kettle] -f [file join $PKG_SRCPATH build.tcl] $action
  } else {
    doexec $::odie(build_tclsh) $::odie(kettle) -f [file join $PKG_SRCPATH build.tcl] $action
  }
}

proc ::gort_bootstrap::build_sqlite {pkg action} {
    ###
    # Sqlite
    ###
    puts "INSTALLING SQLITE"
    set SQLITE_VERSION 3.8.7.2
    set SQLITE_TFNAME sqlite-autoconf-3080704
    set SQLITE_SRCPATH $::odie(sandbox)/sqlite

    cd ${SQLITE_SRCPATH}/tea
    if {![file exists ${SQLITE_SRCPATH}/tea/Makefile]} {
      doexec sh ./configure --prefix=[::cygpath $::odie(local_repo)] --libdir=[::cygpath $::odie(local_repo)/lib] --host=$::odie(host)
    }
    doexec make install
}

proc ::gort_bootstrap::install_package package {
  variable distribution
  set pkginfo [dict get $distribution $package]
  puts [list $package $pkginfo]
  set download [dict get $pkginfo get_proc]
  $download $package
  set build    [dict get $pkginfo build_proc]
  $build $package install
}

proc ::gort_bootstrap::distribution {name properties} {
  variable distribution
  foreach {field value} $properties {
    
    dict set distribution $name $field $value
  }
  if {![dict exists $distribution $name get_proc]} {
    dict set distribution $name get_proc ::noop
  }
  if {![dict exists $distribution $name build_proc]} {
    dict set distribution $name build_proc ::noop
  }
}

::gort_bootstrap::distribution sqlite {
  get_proc   ::noop
  build_proc build_sqlite
  #build_proc ::noop
}

if {!$::odie(windows)} {
    ::gort_bootstrap::distribution tclx {
      get_proc   download_fossil
      build_proc build_gnumake
    }
if 0 {
    ::gort_bootstrap::distribution kettle {
      get_proc   download_fossil
      requires {tclx tcllib tklib}
      build_proc build_kettle
    }
}
}
::gort_bootstrap::distribution tclvfs {
  get_proc   download_fossil
  requires tcllib
  build_proc build_gnumake
}
::gort_bootstrap::distribution taolib {
  get_proc   download_fossil
  requires {sqlite tcllib tklib}
  build_proc build_sak
}
::gort_bootstrap::distribution tcllib {
  get_proc   download_fossil
  fossil_branch odie
  build_proc build_sak
}
::gort_bootstrap::distribution tklib {
  get_proc   download_fossil
  requires tcllib
  build_proc build_sak
}

::gort_bootstrap::distribution odielib {
  get_proc   download_fossil
  fossil_branch autosetup
  requires {tcllib sqlite}
  build_proc build_gnumake
}

::gort_bootstrap::distribution gort {
  get_proc   download_fossil
  fossil_branch trunk
  requires {tcllib odielib taolib sqlite}
  build_proc build_gnumake
}

proc ::doexec args {
  exec {*}$args >&@ stdout
}

###
# Make sure the odielib toolkit is downloaded
###
if {![file exists [file join $::odie(sandbox) odielib modules odie index.tcl]]} {
  ::gort_bootstrap::download_fossil odielib
}
source [file join $path .. odielib modules odie index.tcl]
source [file join $path .. odielib modules cmdline cmdline.tcl]
source [file join $path .. odielib modules fileutil index.tcl]
source [file join $path .. odielib modules codebale index.tcl]



#::gort_bootstrap::distribution gort {
#  get_proc   download_fossil
#  requires {taolib tcllib odielib kettle}
#  build_proc build_kettle
#}

#!/bin/sh
# Copyright (c) 2006-2011 WorkWare Systems http://www.workware.net.au/
# All rights reserved
# vim:se syntax=tcl:
# \
dir=`dirname "$0"`; exec "`$dir/../autosetup/find-tclsh`" "$0" "$@"

###
# Micronized version of gort for bootstrapping Odie
###

set path [file normalize [file join [file dirname [file normalize [info script]]] ..]]
source [file join $path scripts common.tcl]

namespace eval ::command {}

proc ::command::help {} {
  foreach command [lsort -dictionary [info command ::command::*]] {
    puts " * [namespace tail $command]"
  }
}

proc ::command::package-list {} {
  foreach distro [lsort -dictionary [dict keys $::gort_bootstrap::distribution]] {
    puts " * $distro"
  }
}

proc ::command::install {package} {
  if {$package eq "all"} {
    install-all
    return
  }
  ::gort_bootstrap::install_package $package
}

proc ::command::install-all {} {
  set info $::gort_bootstrap::distribution
  set allpkgs [lsort -dictionary [dict keys $info]]
  set installed {}
  foreach item $allpkgs {
    if {[dict exists $info $item requires]} {
      set requires($item) [dict get $info $item requires]
    } else {
      set requires($item) {}

      lappend installed $item
    }
  }
  foreach item $installed {
    puts "INSTALLING $item"
  }
  foreach item $installed {
    ::gort_bootstrap::install_package $item
  }  
}

set method [lindex $argv 0]
if { [info command ::command::$method] eq {} } {
  puts stderr "Invalid command: $method."
  ::command::help
  exit 1
}
::command::$method {*}[lrange $argv 1 end]
update
exit 0

cd ${ODIE_SANDBOX_PATH}/tcl/${ODIE_TCL_PLATFORM_DIR} ; make distclean
cd ${ODIE_SANDBOX_PATH}/tk/${ODIE_TCL_PLATFORM_DIR} ; make distclean
cd ${ODIE_SANDBOX_PATH}/tcl-static/${ODIE_TCL_PLATFORM_DIR} ; make distclean
cd ${ODIE_SANDBOX_PATH}/tk-static/${ODIE_TCL_PLATFORM_DIR} ; make distclean
cd ${ODIE_SANDBOX_PATH}/sqlite/tea ; make distclean
cd ${ODIE_SANDBOX_PATH}/tclvfs ; make distclean
cd ${ODIE_SANDBOX_PATH}/tcllib ; make distclean
cd ${ODIE_SRC_DIR} ; ${ODIE_BUILD_TCLSH} build.tcl clean




find ${ODIE_SRC_DIR} -type d -iname "*.vfs" -exec rm {} \;

if [ ! -f "odieConfig.sh" ]; then
  rm odieConfig.sh
fi
if [ ! -f "odieConfig.tcl" ]; then

set path [file dirname [file normalize [info script]]]
proc ::doexec args {
  exec {*}$args >&@ stdout
}

source $path/../odieConfig.tcl

proc get_distro {pkg {tag trunk} {local_path {}}} {
  if {$local_path eq {}} {
    set local_path $pkg
  }
  set PKG_SRCPATH $::odie(sandbox)/$local_path
  if {![file exists $::odie(download)/$pkg.fos]} {
    puts "Fossil clone $pkg"
    doexec $::odie(fossil) clone $::odie(mirror_url)/$pkg $::odie(download)/$pkg.fos
  }

  if {![file exists ${PKG_SRCPATH}/$::odie(fossil_checkout)]} {
    puts "Fossil open $local_path"
    file mkdir ${PKG_SRCPATH}
    cd ${PKG_SRCPATH}
    doexec $::odie(fossil) open $::odie(download)/$pkg.fos
  }
  cd ${PKG_SRCPATH}
  doexec $::odie(fossil) update $tag
  return ${PKG_SRCPATH}
}

get_distro tcllib odie
get_distro gort trunk
get_distro gort sherpa sherpa

###
# Build supporting libraries needed by Gort
##
file mkdir $::odie(prefix)/bin
# Rebuild gort
set GORT_SRCPATH $::odie(src_dir)/../gort
set SHERPA_SRCPATH $::odie(src_dir)/../sherpa

if {$::tcl_platform(platform) eq "windows"} {

  file copy -force ${GORT_SRCPATH}/gort.tcl $::odie(prefix)/bin/gort.tcl
  file copy -force ${SHERPA_SRCPATH}/sherpa.tcl $::odie(prefix)/bin/sherpa.tcl
} else {
  file delete $::odie(prefix)/bin/gort
  file link -symbolic $::odie(prefix)/bin/gort ${GORT_SRCPATH}/gort.tcl 
  file delete $::odie(prefix)/bin/sherpa
  file link -symbolic $::odie(prefix)/bin/sherpa ${SHERPA_SRCPATH}/sherpa.tcl 
}

echo $ODIE_HOST
echo $ODIE_TARGET

#cd ${SANDBOX}/tcl
#${FOSSIL} update ${TCL_FOSSIL_BRANCH}
cd ${TCL_SRCPATH}
# Build Tcl twice. Once statically, once dynamically
#echo Build Static Tcl
#if [ "${ODIE_HOST}" != "${ODIE_TARGET}" ] ; then
#    sh ./configure --enable-shared=no --with-tzdata --host=${ODIE_TARGET} ${TCL_CONFIG_FLAGS}
#else
#    sh ./configure --enable-shared=no --with-tzdata ${TCL_CONFIG_FLAGS}
#fi
#make clean
#make binaries
#echo "COPYING STATIC LIBRARY"
#source tclConfig.sh
#cp -f $TCL_LIB_FILE ${ODIE_STATIC_TCLLIB}
#cp -f tclConfig.sh ${exec_prefix}/lib/tclkitConfig.sh

#cd ${TCL_SRCPATH}
echo Build Dynamic Tcl
if [ "${ODIE_HOST}" != "${ODIE_TARGET}" ] ; then
    sh ./configure --prefix=${LOCAL_REPO} --libdir=${LOCAL_REPO}/lib --with-tzdata --host=${ODIE_TARGET} ${TCL_CONFIG_FLAGS}
else
    sh ./configure --prefix=${LOCAL_REPO} --libdir=${LOCAL_REPO}/lib --with-tzdata ${TCL_CONFIG_FLAGS}
fi
make clean

source [file join [file dirname [file normalize [info script]]] common.tcl]

package require codebale
::codebale::mkdoc_embedded_html $::odielib(srcroot) $::odielib(modules)  [file join $::odielib(srcroot) autodoc]  \
	-nav {Odie Home} /fossil/odie/home \
	-o /var/www/odie/docs 

puts $fout "<TABLE>"
puts $fout "<tr><th colspan=2>Self contained executables</th></tr>"
if {[file exists $::odie(wish_kit)]} {
  upload $fout $::odie(wish_kit) ${server} $path "Base kit with tk"
}
upload $fout $::odie(tcl_kit) ${server} $path "Base kit with no tk"
upload $fout $::odie(zip_kit) ${server} $path "Sourceable Zipfile"
upload $fout $::odie(gort) ${server} $path "The Gort package manager"
puts $fout "<tr><th colspan=2>Config Files</th></tr>"
upload $fout $here/../odieConfig.sh ${server} $path "Odie Configuration Paramters (sh readable)"
upload $fout $here/../odieConfig.tcl ${server} $path "Odie Configuration Paramters (tcl readable)"
upload $fout ${exec_prefix}/lib/tclConfig.sh ${server} $path "Tcl Configuration Paramters (sh readable)"
upload $fout ${exec_prefix}/lib/tkConfig.sh ${server} $path "Tk Configuration Paramters (sh readable)"
puts $fout "<tr><th colspan=2>Packages</th></tr>"
upload $fout $::odie(toad_kit) ${server} $path "Batteries included binary"