make.tcl from odie

###
# This file contains instructions for how to build the Odielib library
# It will produce the following files in whatever directory it was called from:
#
# * odielibc.mk - A Makefile snippet needed to compile the odielib sources
# * odielibc.c - A C file which acts as the loader for odielibc
# * logicset.c/h - A c
# * (several .c and .h files) - C sources that are generated on the fly by automation
###
# Ad a "just in case" version or practcl we ship locally

set ::CWD [pwd]
set ::SRCDIR [file dirname [file normalize [info script]]]
set ::SANDBOX  [file dirname $::SRCDIR]

if {[file exists [file join $::SRCDIR .. tclconfig practcl.tcl]]} {
  source [file join $::SRCDIR .. tclconfig practcl.tcl]
} else {
  source [file join $::SRCDIR tclconfig practcl.tcl]
}
set ::practcl::CONFIG(sandbox) $::SANDBOX

file mkdir $CWD/build

set ::CWD [pwd]
set dat [::practcl::config.tcl $CWD]
# Handle turning on and off debugging in time to alter the
# make objects
if {"debug" in $argv} {
  dict set dat debug 1
  puts "Enableing Symbols"
  if {[file exists $CWD/config.tcl]} {
    set odat [::practcl::cat $CWD/config.tcl]
  }
  dict set odat debug 1
  set fout [open $CWD/config.tcl w]
  foreach {f v} [::practcl::sort_dict $odat] {
    puts $fout [list $f $v]
  }
  close $fout
}
if {"no-debug" in $argv} {
  dict set dat debug 0
  puts "Disabling Symbols"
  if {[file exists $CWD/config.tcl]} {
    set odat [::practcl::cat $CWD/config.tcl]
  }
  dict set odat debug 0
  set fout [open $CWD/config.tcl w]
  foreach {f v} [::practcl::sort_dict $odat] {
    puts $fout [list $f $v]
  }
  close $fout
}
::practcl::tclkit  create BASEKIT $dat

BASEKIT define set sandbox $::SANDBOX
BASEKIT define set name toadkit
BASEKIT define set name toadkit
BASEKIT define set version 0.1
BASEKIT define set localpath toadkit
BASEKIT define set profile devel
BASEKIT define set prefix /tcl
BASEKIT define set installdir [file join $::CWD PKGROOT]
BASEKIT define set USEMSVC    [info exists env(VisualStudioVersion)]
BASEKIT define set prefix_broken_destdir [file join $::SANDBOX tmp]
if {[BASEKIT define get debug 0]} {
  BASEKIT define set tclkit_bare [file join $CWD tclkit_debug[BASEKIT define get EXEEXT]]
} else {
  BASEKIT define set tclkit_bare [file join $CWD tclkit_bare[BASEKIT define get EXEEXT]]
}
BASEKIT define set output_c       toadkit.c
BASEKIT define set libs   	 {}
BASEKIT source [file join $::SRCDIR basekit.ini]

::practcl::target tcltk {
  depends {deps configure clean local-env}
  triggers {script-packages script-pkgindex}
  filename [file join $CWD config.tcl]
}
::practcl::target debug {
  triggers toadkit
}
::practcl::target no-debug {
  triggers toadkit
}
::practcl::target clean {
}
::practcl::target local-env {
  aliases local
}
::practcl::target basekit {
  depends {deps tcltk practcl}
  triggers {}
  filename [file join $CWD [BASEKIT define get tclkit_bare]]
}
::practcl::target odielib {
  triggers {basekit toadkit}
}
::practcl::target packages {
  depends {deps tcltk practcl}
}
::practcl::target upgrade {
  triggers {clean basekit tcltk deps packages toadkit}
}
::practcl::target toadkit {
  aliases example
  depends {deps tcltk basekit packages practcl}
}
::practcl::target practcl {
  filename [file join $::SANDBOX tclconfig practcl.tcl]
}
::practcl::target distclean {}

switch [lindex $argv 0] {
  os {
    puts "OS: [practcl::os]"
    set dat [::practcl::local_os]
    foreach {var val} $dat {
      puts "${var}: $val"
    }
    set preffile [file join [dict get $dat userhome] practcl.rc]
    puts "PREFS: $preffile"
    if {[file exists $preffile] } {
      set dat [::practcl::read_rc_file $preffile]
      foreach {f v} $dat {
        puts "$f: $v"
      }
    }
    #parray ::project
    exit 0
  }
  info {
    puts "OS: [practcl::os]"
    foreach {var val} [::practcl::local_os] {
      puts "${var}: $val"
    }
    puts ***
    foreach item [BASEKIT link list core.library] {
      puts " [list PACKAGE [$item define get name]]"
      foreach {f v} [$item define dump] {
        puts "  $f: $v"
      }
    }
    foreach item [BASEKIT link list package] {
      puts " [list PACKAGE [$item define get name]]"
      foreach {f v} [$item define dump] {
        puts "  $f: $v"
      }
    }
    exit 0
  }
  wrap {
    ::practcl::depends basekit
  }
  all {
    # Auto detect missing bits
    ::practcl::trigger toadkit
  }
  local {
    # Build local packages
    set prefix [lindex $argv 1]
    if {$prefix eq {}} {
      set prefix [file normalize [file join ~ tcl]]
    }

  }
  package-get {
    foreach {package version} [lrange $argv 1 end] {
      set obj [BASEKIT project $package]
      $obj define set scm_tag $version
      $obj update
    }
    exit 0
  }
  package {
    ::practcl::trigger packages
  }
  default {
    ::practcl::trigger {*}$argv
  }
}

if {[catch {
if {$make(clean) || $make(distclean) || $make(upgrade)} {
  set triggers {}
  foreach {item value} [array get make] {
    if {$value} { lappend triggers $item }
  }
  foreach fname {PKGROOT pkg toadkit.c toadkit.h toadkit.vfs kitcrypt.c} {
    if {[file exists [file join $CWD $fname]]} {
       file delete -force [file join $CWD $fname]
    }
  }
  foreach file [glob -nocomplain $CWD/pkg/*] {
    file delete -force $file
  }
  foreach file [glob -nocomplain $CWD/build/*] {
    file delete -force $file
  }
  foreach file [glob -nocomplain $CWD/objs/*] {
    file delete -force $file
  }
  #foreach {item fname} [array get ::target] {
  # if {[file exists $fname]} {
  #    file delete $fname
  #  }
  #}
  # Re-apply triggers
  ::practcl::trigger {*}$triggers
}

if {$make(distclean)} {
  # Clean all source code back to it's pristine state from fossil
  foreach item [BASEKIT link list package] {
    $item go
    set projdir  [$item define get localsrcdir]
    if {$projdir ne {} && [file exists $projdir]} {
      fossil $projdir clean -force
    }
  }
}

file mkdir [file join $CWD build]
if {$make(upgrade)} {
  set INSTALLDIR [BASEKIT define get installdir]
  foreach item {tclconfig tcl tk critcl sqlite} {
    set obj [::practcl::LOCAL tool $item]
    $obj update
  }
  foreach item [BASEKIT link list package] {
    puts [list Updating $item [$item define get srcdir]]
    $item update
  }
}

if {$make(local-env)} {
  puts "BUILDING LOCAL TCL ENVIRONMENT"
  foreach item {tclconfig tcl tk critcl sqlite} {
    set obj [::practcl::LOCAL tool $item]
    puts [list $item $obj]
    if {[catch {$obj env-install} err errdat]} {
      puts ***
      puts [dict get $errdat -errorinfo]
      puts ***
    }
  }
}

if {$make(tcltk)} {
  BASEKIT build-tclcore
}

if {$make(practcl)} {
  set tclConfigObj [::practcl::LOCAL tool tclconfig]
  $tclConfigObj env-load
}

if {$make(odielib)} {
  BASEKIT project odielib clean
  BASEKIT project odielib compile
}

if {[lindex $argv 0] eq "package"} {
  #set result {}
  set INSTALLDIR [BASEKIT define get installdir]
  foreach item [lrange $argv 1 end] {
    set obj [BASEKIT project $item]
    puts [list build $item [$obj define get static] [info object class $obj]]
    if {[string is true [$obj define get static]]} {
      $obj compile
    }
    if {[string is true [$obj define get vfsinstall]]} {
      $obj install $INSTALLDIR
    }
  }
  #puts "RESULT: $result"
} elseif {$make(packages)} {
  puts "CHECKING PACKAGE LIST"
  set INSTALLDIR [BASEKIT define get installdir]
  foreach item [BASEKIT link list package] {
    puts [list GENERATING $item [$item define get srcdir]]
    if {[string is true [$item define get static 0]]} {
      $item compile
    }
    if {[string is true [$item define get vfsinstall 1]]} {
      if {[catch {$item install $INSTALLDIR} error errdat]} {
        puts stderr "BUILD FAILURE $item"
        puts "FAILED TO  INSTALL package $item"
        puts [dict get $errdat -errorinfo]
        exit 1
      }
    }
  }
}

if {$make(basekit)} {
  BASEKIT implement $CWD
  if {![file exists [file join $CWD make.tcl]]} {
    set fout [open [file join $CWD make.tcl] w]
    puts $fout [list source [file join $::SRCDIR make.tcl]]
    close $fout
  }
  BASEKIT build-tclsh $target(basekit) BASEKIT
}

if {[lindex $argv 0] eq "wrap"} {
  BASEKIT wrap $CWD {*}[lrange $argv 1 end]
}

if {$make(toadkit)} {
  puts [list DEBUG: [BASEKIT define get debug 0]]
  set VFS [file join $CWD toadkit.vfs]
  file mkdir $VFS
  # Copy in our "secret squirrel" code
  #set SCMCOPY [list ::exec [BASEKIT define get tclkit_bare] [file join $::SRCDIR scripts scm-copy.tcl]]
  set SCMCOPY ::practcl::copyDir
  {*}$SCMCOPY [file join $::SRCDIR src] ${VFS}
  if {[BASEKIT define get debug 0]} {
    BASEKIT wrap $CWD toadkit_debug $VFS [file join $CWD PKGROOT]
  } else {
    BASEKIT wrap $CWD toadkit $VFS [file join $CWD PKGROOT]
  }
}
} err errdat]} {
  set logfile [file join $::CWD practcl.log]
  ::practcl::log $logfile "###\n# Error Trace\n###"
  ::practcl::log $logfile [dict get $errdat -errorinfo]
  ::practcl::log $logfile "###\n# DEBUG INFO\n###"
  ::practcl::log $logfile $::DEBUG_INFO
  puts stderr $err
  puts stderr "Failure logged to $logfile"
  exit 1
}