;;;; A program that pushes values into the watch table from its own loop.
;;;;
;;;; The point of the case is that this needs no compiler change: the watch
;;;; entry points are ordinary C functions, so a program reaches them through
;;;; [declare-c] the same way it reaches anything else in the runtime. That is
;;;; deliberate — a [(watch "hp" hp)] form would be an arm in the checker, and
;;;; a scalar does not need one.
;;;;
;;;; The values are written every iteration and are *not* read back from here.
;;;; What reads them is the daemon's [watch] op, over the agent, while this
;;;; program is still running — which is the whole design: the program pushes
;;;; at frame rate and the editor reads memory.
(import agent "vendor:agent")

(declare-c watch-i64 [name string x i64] i32 "flan_dev_watch_i64")
(declare-c watch-f64 [name string x f64] i32 "flan_dev_watch_f64")
(declare-c watch-str [name string s string] i32 "flan_dev_watch_str")

(defvar ticks i64)

(defn step [] i64
  (set ticks (+ ticks 1))
  ;; Three types, because the table stores *rendered text* and the rendering
  ;; is per type: an i64 and an f64 do not print the same way, and a string is
  ;; quoted and escaped so that a newline in one cannot become a second row.
  (watch-i64 "ticks" ticks)
  (watch-f64 "half" (/ (f64 ticks) 2.0))
  (watch-str "label" "sand")
  ticks)

(defn main [] i32
  (agent/start "/tmp/flan-dev-watch-fallback.sock")
  ;; A watch call costs a load and a not-taken branch until somebody opens a
  ;; watch buffer, so spinning here writes nothing until the test arms it.
  (while (= (agent/wait 20) 0) (step))
  (step)
  (while (= (agent/wait 20) 0) (step))
  0)