boot.folk

# This program gets directly evaluated at the top level.

apply {{} {
    # We setpgrp so that all subprocesses spawned by Folk, even ones
    # that outlive Folk itself, can be killed later by their PGID (the
    # PID in folk.pid).
    catch { setpgrp }

    catch {
        set fp [open "folk.pid" r]
        set oldPid [read $fp]; close $fp
        try {
            if {[string trim [exec ps -o state= -p $oldPid]] eq "Z"} {
                error "Zombie Folk process exists (PID $oldPid)"
            }
            puts $::realStderr "boot: ($::errorCode) ERROR: Another Folk (PID $oldPid) already running."
            Exit! 1
        } on error e {
            if {$e ne ""} {
                puts stderr "boot: $e; this is OK; continuing."
            }
        }
    }

    set fp [open "folk.pid" w]
    puts -nonewline $fp [pid]; close $fp
    # in case we're running as root:
    catch { exec chown folk folk.pid }
}}

__installLocalStdoutAndStderr "boot.folk"

Assert! when /_this/ has program code /programCode/ {
    if {$_this eq "builtin-programs/collect.folk"} {
        # We don't have Collect available in boot.folk yet, since it's
        # implemented in userspace, so we can't do the queries. Just
        # run it always.
        SayWithSource $_this 1 0 {} {} \
            when $programCode with environment [list [list this $_this]]
        return
    }

    When /nobody/ wishes program $_this does not run {
        When /nobody/ wishes program $_this is replaced with /...anything/ {
            SayWithSource $_this 1 0 {} {} \
                when $programCode with environment [list [list this $_this]]
        }
        When /someone/ wishes program $_this is replaced with /...replacedOpts/ {
            SayWithSource $_this 1 0 {} {} \
                when [dict get $replacedOpts code] with environment [list [list this $_this]]
        }
    }
} with environment {}

local proc LoadProgram! {programFilename} {
    set fp [open $programFilename r]
    set code [read $fp]
    close $fp

    set editedPath "$::env(HOME)/folk-data/program/[regsub {\.folk$} $programFilename {}].folk.edited"
    if {[file exists $editedPath]} {
        set efd [open $editedPath r]
        set code [read $efd]
        close $efd
    }

    Hold! -on boot.folk -key [list $programFilename code] \
        -keep 100ms \
        Claim $programFilename has program code $code
}
foreach programFilename [list {*}[glob -nocomplain builtin-programs/*.folk] \
                             {*}[glob -nocomplain builtin-programs/*/*.folk] \
                             {*}[glob -nocomplain "user-programs/[info hostname]/*.folk"] \
                             {*}[glob -nocomplain "$::env(HOME)/folk-data/local-program/*.folk"] \
                             {*}[glob -nocomplain "$::env(HOME)/folk-data/local-program/*/*.folk"]] {
    if {[string match "*/_archive/*" $programFilename]} {
        continue
    }

    LoadProgram! $programFilename
}

if {$::tcl_platform(os) eq "darwin"} {
    # HACK: We must run all the GPU and window setup stuff
    # synchronously in the main thread on macOS.

    proc fake {s} {
        set __envStack [list]

        rename When When'
        proc When args {
            set pattern [lrange $args 0 end-1]
            # Await the dependencies being available.
            while {[llength [Query! {*}$pattern]] != 1} {
                sleep 0.1
            }

            if {[lrange $pattern 0 3] eq {the GPU texture library}} {
                # HACK: We want Whens inside this block to be normal
                # Whens and run off-thread/async.
                rename When {}
                rename When' When
            }

            tailcall ForEach! {*}$args
        }

        source $s

        rename When {}
        rename When' When
    }
    fake "builtin-programs/gpu/gpu.folk"
    fake "builtin-programs/gpu/draw.folk"
}