dependencies.stanza

;; See license.txt for details about licensing.

defpackage stz/dependencies :
   import core
   import collections
   import reader
   import macro-utils
   import stz/input
   import stz/compiler
   import stz/core-macros
   import stz/arg-parser
   import stz/params
   import stz/utils
   import stz/algorithms
   import stz/renamer
   import stz/resolver
   import stz/type
   import stz/type-to-kform
   import stz/kform
   import stz/kform-to-tgt
   import stz/pl-ir
   import stz/il-ir
   import stz/tl-ir
   import stz/kl-ir
   import stz/asm-ir
   import stz/tgt-ir
   import stz/tgt-utils
   import stz/namemap
   import stz/backend
   import stz/codegen
   import stz/asm-emitter
   import stz/pkg
   import stz/fuse
   import stz/compiler
   import stz/ast-lang
   import stz/reader-lang
   import stz/check-lang
   import stz/renamer-lang
   import stz/resolver-lang
   import stz/serializer-lang
   import stz/ast-printer-lang
   import registry

var *build-dir* = "debug"
var *build-opt* = ""

defn macroexpand (forms:List) -> List :
  val es = parse-syntax[core / #exps!](forms)
  cons(`$begin, es)

defn filename-packages (filenames:Seqable<String>) -> HashTable<String,List<IPackage>> :
  defn packages (e:IExp) :
    to-list $ generate<IPackage> :
      let loop (e:IExp = e) :
        match(e) :
          (e:IPackage) :
            check(e)
            yield(e)
          (e:IBegin) :
            do(loop, exps(e))
          (e) :
            false
  defn packages (filename:String) :
    throw(InvalidExtensionError(filename)) when not suffix?(filename,".stanza")
    packages(read-prog(macroexpand(read-file(filename))))
  to-hashtable<String, List<IPackage>> $ for filename in filenames seq :
    filename => packages(filename)

defn pkg-name (name:Symbol) -> String :
  string-join([*build-dir* "/" replace(to-string $ name, "/", "$$") ".pkg"])

defn non-suffix (filename:String) :
  val index = last-index-of-char(filename, '.')
  filename[0 to (index as Int)]
    
defn obj-filename (filename:String) :
  non-suffix(base-name(filename))

;; TODO: CURRENTLY DOESN'T HELP BECAUSE AREN'T PART OF MODELED DEPENDENCIES
defn update-cpp-link (link:Link) :
  switch(os(link)) :
    `Darwin :    [Link(os(link), to-tuple $ cat(value(link), ["-lc++"]))]
    `GNU/Linux : [Link(os(link), to-tuple $ cat(value(link), ["-lstdc++"]))]
    `* :         cat(update-cpp-link(Link(`Darwin, value(link))), update-cpp-link(Link(`GNU/Linux, value(link))))

defn update-cpp-package (pkg:Package) :
  Package(name(pkg), dependencies(pkg), to-list $ cat-all(seq(update-cpp-link, links(pkg))))

defn update-cpp-file (file:File) :
  if suffix?(name(file), ".cpp") :
    val default-package = Package(to-symbol(name(file)), List(), List(Link(`*, [])))
    val pkgs = to-list $ [default-package] when empty?(packages(file)) else packages(file)
    File(name(file), kind(file), flags(file), syntax(file), map(update-cpp-package, pkgs))
    ;; println("# UPDATING CPP %_" % [res])
  else :
    file

public defn gen-dependencies (i-all-files:Seqable<File>) :
  val all-files = to-list $ seq(update-cpp-file, i-all-files)
  val files0 = to-tuple $ for file in all-files filter : suffix?(name(file), ".stanza")
  val filenames = to-list $ seq(name, filter({ kind(_) != `gen}, files0))
  val filename-pkgs = filename-packages(filenames)
  val file-table0 = to-hashtable<String, File> $ seq(fn (f) : name(f) => f, files0)

  val graph = HashTable<Symbol, List<Symbol>>()
  val package-filename = HashTable<Symbol, String>()
  
  val files = to-tuple $ generate<File> :
    for kv in filename-pkgs do :
      val filename = key(kv)
      val file = file-table0[filename]
      val pkgs = generate<Package> :
        val pkg-table = to-hashtable<Symbol, Package> $ seq(fn (p) : name(p) => p, packages(file))
        for pkg in value(kv) do :
          val pkg-name = name!(pkg)
          package-filename[pkg-name] = filename
          graph[pkg-name] = to-list $ for imp in imports(pkg) seq : name!(package(imp as IImport))
          yield(get?(pkg-table, pkg-name, Package(pkg-name, List(), List())))
      yield(File(name(file), kind(file), flags(file), syntax(file), to-list $ pkgs))
    for file in files0 do :
      if kind(file) == `gen :
        val pkg = Package(to-symbol $ obj-filename(name(file)), List(), List())
        package-filename[name(pkg)] = name(file)
        graph[name(pkg)] = List()
        yield(File(name(file), kind(file), flags(file), syntax(file), List(pkg)))

  ;; println-all(["FILES " files])

  val file-table = to-hashtable<String, File> $ seq(fn (f) : name(f) => f, files)

  val groups = strong-components(graph)
  
  ;; for group in groups do :
  ;;   println("# %_" % [group])

  ;; for kv in graph do :
  ;;   println-all(["PKG " key(kv) " IMPORTS " value(kv)])

  defn user? (name:Symbol) :
    kind(file-table[package-filename[name]]) != `stz

  val pkgs = to-hashtable<Symbol, Package> $ generate<KeyValue<Symbol, Package>> :
    for file in files do :
      for package in packages(file) do :
        yield(name(package) => package)
      for package in get?(filename-pkgs, name(file), List()) do :
        if not contains?(seq(name, packages(file)), name!(package)) :
          yield(name!(package) => Package(name!(package), List(), List()))
      
  println("%__STZ_FLAGS = -pkg %_ %_" % [*build-dir* *build-dir* *build-opt*])
  println("")

  print("%_/all:" % [*build-dir*])
  for file in filter({ contains?([`app, `plugin], _) }, files) do :
    print(" %_/%_" % [*build-dir* obj-filename(name(file))])
  println("\n\tmkdir -p %_" % [*build-dir*])
  println("")

  println("%_/clean: "% [*build-dir*])
  println("\trm -f %_/*" % [*build-dir*])
  println("")

  defn compiler-of (file:File) -> [String, True|False] :
    match(syntax(file)) :
      (s:Syntax) : [string-join([*build-dir* "/" value(s) "-stanza"]), true]
      (s:False) : ["${STZ}", false]
  
  val group-name = HashTable<Symbol, Symbol>()
  
  for group in groups do :
    match(group) :
      (elts:List<Symbol>) : 
        for e in elts do :
          group-name[e] = head(elts)
      (elt:Symbol) :
        group-name[elt] = elt

  defn print-rule (team:List<Symbol>) :
    val e = head(team)
    val file = file-table[package-filename[e]]
    if contains?([`std, `mac, `app, `plugin], kind(file)) :
      print("%s: %s" % [seq(pkg-name, team) seq({package-filename[_]}, team)])
      for guy in team do :
        for import in unique(seq({ group-name[_] }, graph[guy])) do :
          if e != import : 
            print(" %_" % [pkg-name(import)]) when user?(import)
        for dep in dependencies(pkgs[guy]) do :
          print(" %_" % [value(dep)])
      val [compiler, compiler?] = compiler-of(file-table[package-filename[e]])
      print(" %_" % [compiler]) when compiler?
      println("")
      val file-set = HashSet<String>()
      for pkg-name in team do :
        add(file-set, package-filename[pkg-name]) when user?(pkg-name)
      val files = to-tuple $ file-set
      println("\t%_ %_ ${%__STZ_FLAGS}" % [compiler string-join(files, " ") *build-dir*])
      println("")

  for group in groups do :
    match(group) :
      (elts:List<Symbol>) :
        print-rule(elts)
      (elt:Symbol) :
        print-rule(List(elt))

  val c-files = to-tuple $ for file in all-files filter : suffix?(name(file), ".c")
  for file in c-files do :
    println("%_/%_.o: %_" % [*build-dir* obj-filename(name(file)) name(file)])
    val flags = "" when flags(file) is False else flags(file)
    println("\t${CC} %_ -c ${CFLAGS} -o %_/%_.o %_" % [flags *build-dir* obj-filename(name(file)) name(file)])
    println("")

  val cpp-files = to-tuple $ for file in all-files filter : suffix?(name(file), ".cpp")
  for file in cpp-files do :
    println("%_/%_.o: %_" % [*build-dir* obj-filename(name(file)) name(file)])
    val flags = "" when flags(file) is False else flags(file)
    println("\tc++ %_ -c ${CFLAGS} -o %_/%_.o %_" % [flags *build-dir* obj-filename(name(file)) name(file)])
    println("")

  val gen-files = to-tuple $ for file in files filter : kind(file) == `gen
  for file in gen-files do :
    val obj = obj-filename(name(file))
    val base = obj[length("eval-") to false]
    println("%_/%_.stanza: %_/gen-repl %_/eval.pkg %_" % [*build-dir* obj *build-dir* *build-dir* pkg-name(to-symbol $ base)])
    println("\t%_/gen-repl %_ ${STANZADIR} %_" % [*build-dir* *build-dir* base])
    println("")
    println("%_: %_/%_.stanza" % [pkg-name(to-symbol $ obj) *build-dir* obj])
    println("\t${STZ} %_/%_.stanza ${%__STZ_FLAGS}" % [*build-dir* obj *build-dir*])
    println("")

  ;; val mac-files = to-tuple $ for file in files filter : kind(file) == `mac
  ;; for file in mac-files do :
  ;;   println("%_/%_-stanza: %_" % [*build-dir* obj-filename(name(file)) name(file)])
  ;;   println("\tstanza %_ ${STZ_COMPILER_MAIN} -flags OPTIMIZE -s %_/%_.s -o %_/%_-stanza" % [name(file) *build-dir* obj-filename(name(file)) *build-dir* obj-filename(name(file))])
  ;;   println("")

  defn used-packages (pkg-roots:Seqable<Package>) :
    val used = HashTable<Symbol, Package>()
    defn loop (root:Package) -> False :
      if not key?(used, name(root)) :
        used[name(root)] = root
        do(fn (i): loop(pkgs[i]) when key?(pkgs, i), graph[name(root)])
    do(loop, pkg-roots)
    values(used)

  defn direct-packages (pkgs:Seqable<Package>) :
    unique(cat-all(seq({ graph[name(_)] }, pkgs)))

  defn os-links (os-name:Symbol, pkgs:Seqable<Package>) :
    generate<Link> :
      for pkg in pkgs do :
        for link in links(pkg) do :
          if os(link) == os-name or os(link) == `* :
            yield(link)

  for file in files do :
    if contains?([`app, `plugin `mac], kind(file)) :
      val [compiler, compiler?] = compiler-of(file)
      val used-pkgs = to-tuple $ used-packages(packages(file))
      val direct-pkgs = to-tuple $ direct-packages(packages(file))
      val app-filename = string-join([obj-filename(name(file)) ("-stanza" when kind(file) == `mac else "")])
      ;; println("# USED-PKGS %_" % [used-pkgs])
      ;; ADD DEFAULT C++ LINKING -- TODO: IMPROVE TO ONLY ADD IF NEEDED
      val mac-links   = cat(os-links(`Darwin, used-pkgs),    [ Link(`Darwin,    ["-lc++"]) ])
      val linux-links = cat(os-links(`GNU/Linux, used-pkgs), [ Link(`GNU/Linux, ["-lstdc++"]) ])
      println("ifeq ($(OS2), Darwin)")
      defn unique-join (flags:Seqable<String>) -> String :
        string-join(unique $ flags, " ")
      val mac-extra-flags = ["-dynamiclib"] when kind(file) == `plugin else []
      println("  %__FLAGS = %_" % [app-filename, unique-join(cat(cat-all(seq(value, mac-links)), mac-extra-flags))])
      println("  %__APP = %_%_" % [app-filename, app-filename, ".dylib" when kind(file) == `plugin else ""])
      println("else")
      println("  OS := $(strip $(shell uname -o))")
      println("  ifeq ($(OS), GNU/Linux)")
      val linux-extra-flags = ["-shared"] when kind(file) == `plugin else []
      println("    %__FLAGS = %_" % [app-filename, unique-join(cat(cat-all(seq(value, linux-links)), linux-extra-flags))])
      println("    %__APP = %_%_" % [app-filename, app-filename, ".so" when kind(file) == `plugin else ""])
      println("  endif")
      println("endif")
      println("")
      val imports = join(unique(seq({ pkg-name(group-name[_]) }, filter(user?, direct-pkgs))), " ")
      println("%_/%_: %_ %* %_" % [*build-dir* app-filename, name(file), imports, compiler when compiler? else ""])
      ;; println("%_/%_: %_ %* %_" % [*build-dir* app-filename, name(file), join(seq({ pkg-name(_) }, filter(user?, direct-pkgs)), " "), compiler when compiler? else ""])
      println("\t%_ %_ -o %_/${%__APP} -s %_/%_.s ${%__STZ_FLAGS} -ccflags \"${%__FLAGS}\"" %
        [compiler, string-join([name(file) (" ${STZ_COMPILER_MAIN}" when kind(file) == `mac else "")])
         *build-dir* app-filename *build-dir* app-filename *build-dir* app-filename])
      println("")

defn InvalidExtensionError (filename:String) :
  new Exception :
    defmethod print (o:OutputStream, this) :
      print(o, "File %_ does not have a valid Stanza file extension." % [filename])

defn main () :
  val filename = command-line-arguments()[1]
  val input = to-tuple $ registry-files(filename)
  ;; println("# %_" % [input])
  ;; println(stanza-files)

  println("STZ = stanza")
  println("STANZADIR = `python stanza-utils/stanza-install-dir.py`")
  println("STZ_COMPILER_MAIN = ${STANZADIR}/compiler/stz-driver.stanza")
  println("OS2 := $(strip $(shell uname))")
  println("")
  println("ifeq ($(OS2), Darwin)")
  println("  $(info Compiling for Darwin)")
  println("  CFLAGS = -DMACOSX=1")
  println("  LIBS = $(COMMON_LIBS)")
  println("else")
  println("  $(info Compiling for non Darwin)")
  println("  OS := $(strip $(shell uname -o))")
  println("  ifeq ($(OS), GNU/Linux)")
  println("    $(info Compiling for GNU/Linux)")
  println("    CFLAGS = ")
  println("    LIBS = $(COMMON_LIBS) -lm")
  println("  endif")
  println("endif")
  println("")

  for [dir, opt] in [["release", "-optimize"] ["debug" ""]] do :
    let-var *build-dir* = dir :
      let-var *build-opt* = opt :
        gen-dependencies(input)

main()