;;; skelfile --- CC/core skelfile -*- mode: skel; -*-

 :name "core"

 :author ("Richard Westhaver" . "ellis@rwest.io")

 :version "0.1.0"

 :license "MPL"

 :stash ".stash"

 :store ".store"

 :description "The Compiler Company Core"

 :tags ("core" "lisp" "rust" "emacs" "c")

 :include ("lisp/lisp.sk" "rust/rust.sk" "emacs/emacs.sk")

 :vc (:hg "https://vc.compiler.company/core")

 :bind ((stash ".stash")

        ;; (cc :env "clang")

        (emacs-locals :dir-locals

         (nil . ((indent-tabs-mode . nil)))

         (rust-mode . ((eglot-workspace-configuration

                        . (:rust-analyzer (:cargo (:buildScripts (:enable t) (:features "all")))))))

         (nushell-mode . ((nushell-indent-offset . 2)))

         (nushell-ts-mode . ((nushell-indent-offset . 2)))

         (sh-mode . (sh-indentation . 2))

         (makefile-mode . ((indent-tabs-mode . t)))

         (slint-mode . ((slint-indent-level . 2)))))

 :components ((:org "readme")

              (:mod "emacs")

              (:mod "lisp")

              (:mod "rust"))

 :rules

 ((all (%stash

        psl.dat parquet.json rgb.txt

        save-std save-prelude save-user

        save-infra save-core save-tests

        build-tree-sitter-alien build-core fasls

        ;; build-skel build-organ build-homer build-packy build-rdb

        ;; rust-bin

        ))

  (clean ()

         #$rm -vrf .stash$#

         #$find emacs -name '*.elc' -type f -delete$#

         #$find lisp -name '*.fasl' -type f -delete$#

         #$echo 'cargo clean:' && cd rust && cargo clean$#)

  (tree-sitter-alien ()

                     (:build () #$cd lisp/ffi/tree-sitter &&

                             clang -g -O2 -Wall -Wno-unused-value -ltree-sitter -shared \

                             alien.c -o ../../../.stash/libtree-sitter-alien.so$#)

                     (:install () #$cp .stash/libtree-sitter-alien.so /usr/local/lib/$#))

  (psl.dat (%stash)

           (download "https://publicsuffix.org/list/public_suffix_list.dat"

                     :output (merge-pathnames

                              ".stash/psl.dat"

                              *skel-path*)))

  (rgb.txt (%stash)

           (download "https://packy.compiler.company/data/rgb.txt"

                     :output (merge-pathnames

                              ".stash/rgb.txt"

                              *skel-path*)))

  (x11.lisp (rgb.txt)

            (color::parse-x11-color-definitions

             :input ".stash/rgb.txt"

             :output (merge-pathnames "color/x11.lisp" *skel-path*)))

  (parquet.thrift (%stash)

                  (download

                   "https://raw.githubusercontent.com/apache/parquet-format/master/src/main/thrift/parquet.thrift"

                   :output (merge-pathnames ".stash/parquet.thrift" *skel-path*))

                  #$thrift --gen json -out .stash .stash/parquet.thrift$#)

  (parquet.json (%stash)

                (download "https://packy.compiler.company/data/parquet.json"

                          :output (merge-pathnames ".stash/parquet.json" *skel-path*)))

  (freedesktop.org.xml (%stash)

                       (download "https://packy.compiler.company/data/freedesktop.org.xml"

                                 :output (merge-pathnames ".stash/freedesktop.org.xml" *skel-path*)))

  (parquet-test-data (%stash) (download "https://packy.compiler.company/data/test/alltypes_plain.parquet"

                                        :output (merge-pathnames ".stash/alltypes_plain.parquet" *skel-path*)))

  ;; lisp

  (%stash () #$mkdir -pv .stash$#)

  (rdb (%stash)

       (:build ()

               (with-sbcl (:noinform t :quit t)

                 (ql:quickload :bin/rdb)

                 (asdf:make :bin/rdb))

               #$mv lisp/bin/rdb .stash/rdb$#)

       (:install () #$install -C -m 755 .stash/rdb /usr/local/bin/rdb$#))

  (skel (%stash)

        (:build ()

                (with-sbcl (:noinform t :quit t)

                  (ql:quickload :bin/skel)

                  (asdf:make :bin/skel))

                #$mv lisp/bin/skel .stash/skel$#)

        (:build-gui ()

                    (with-sbcl (:noinform t :quit t)

                      (push :tools *features*)

                      (ql:quickload :bin/skel)

                      (asdf:make :bin/skel))

                    #$mv lisp/bin/skel .stash/skel$#)

        (:install () #$install -C -m 755 .stash/skel /usr/local/bin/skel$#))

  (organ (%stash)

         (:build () (with-sbcl (:noinform t :quit t)

                      (ql:quickload :bin/organ)

                      (asdf:make :bin/organ))

                 #$mv lisp/bin/organ .stash/organ$#))

  (homer (%stash)

         (:build () (with-sbcl (:noinform t :quit t)

                      (ql:quickload :bin/homer)

                      (asdf:make :bin/homer))

                 #$mv lisp/bin/homer .stash/homer$#))

  (packy (%stash)

         (:build () (with-sbcl (:noinform t :quit t)

                      (ql:quickload :bin/packy)

                      (asdf:make :bin/packy))

                 #$mv lisp/bin/packy .stash/packy$#))

  (std () (:save () (with-sbcl (:noinform t :quit t)

                      (ql:quickload :std)

                      (in-package :std-user)

                      (compile-lisp :std :save ".stash/std.core"))))

  (prelude ()

           (:save () (with-sbcl (:noinform t :quit t)

                       (ql:quickload :prelude)

                       (in-package :std-user)

                       (compile-lisp :prelude :save ".stash/prelude.core")))

           (:compile () (compile-lisp :prelude :force t :verbose t)))

  (user ()

        (:save () (with-sbcl (:noinform t :quit t)

                    (ql:quickload :user)

                    (in-package :user)

                    (compile-lisp :user :save ".stash/user.core")))

        (:compile () (compile-lisp :user :force t :verbose t)))

  (infra () (:save () (with-sbcl (:noinform t :quit t)

                        (ql:quickload :user)

                        (in-package :user)

                        (compile-lisp :user :save ".stash/infra.core" :compression 22))))

  (core ()

        (:build () (with-sbcl (:noinform t :quit t)

                     (ql:quickload :bin/core)

                     (asdf:make :bin/core))

                #$mv lisp/bin/core .stash/core$#)

        (:save () (with-sbcl (:noinform t :quit t)

                    (ql:quickload (list :std :core))

                    (in-package :std-user)

                    (compile-lisp :core :save ".stash/core.core")))

        (:compile () (compile-lisp :core :force t :verbose t))

        (:install () #$install -C -m 755 .stash/core /usr/local/bin/core

                  echo "core -> /usr/local/bin/"

                  links="skel homer packy rdb organ"

                  for i in $links; do

                  ln -sf /usr/local/bin/core /usr/local/bin/$i

                  echo "$i -> core -> /usr/local/bin/"

                  done$#))

  (tests ()

         (:save () (with-sbcl (:noinform t :quit t)

                     (ql:quickload :core/tests)

                     (in-package :core/tests)

                     (compile-lisp :core/tests :save ".stash/tests.core")))

         (:compile () 

                   (compile-lisp :core/tests :force t :verbose t)))

  (bench () (:compile () (compile-lisp :core/bench :force t :verbose t)))

  (fasls (compile-core #+nil compile-tests compile-bench compile-user compile-prelude))

  ;; rust

  (mailman () #$cd rust && cargo build -Z unstable-options --bin mailman --artifact-dir ../.stash/$#)

  (alik () #$cd rust && cargo build -Z unstable-options --bin alik --artifact-dir ../.stash/$#)

  (rust-bin (mailman alik))

  (alik-ui () #$trunk build --config rust/ui/alik/Trunk.toml$#)

  ;; install

  (install (install-core) 

           #$d=/usr/local/share/lisp/

           cd .stash

           if [ -d $d ];

           then

           for f in $(find . -type f -name "*.core")

           do echo "$(basename $f) -> $d"

           install -C -m 755 $f $d

           done fi$#)

  (emacs () #$make -C emacs$#)

  ;; TODO 2024-09-15: 

  (core-syms.sxp () (with-open-file (f ".stash/symbols.sxp" :direction :output)))

  (dist-clean (clean) #$cd .. && tar -I 'zstd' -cf core/core-source.tar.zst core/* && cd core

              mkdir -pv .stash

              mv core-source.tar.zst .stash/$#))