From 6a4e2ccd17dbbc77c58532dc9f29df145e7dad5c Mon Sep 17 00:00:00 2001
From: Scott Richmond <kredati@users.noreply.github.com>
Date: Wed, 5 Jun 2024 13:01:43 -0400
Subject: [PATCH] continue integration work: basic framework

---
 janet/errors.janet | 10 +++++++
 janet/ludus.janet  | 72 ++++++++++++++++++++++++++++++----------------
 2 files changed, 58 insertions(+), 24 deletions(-)
 create mode 100644 janet/errors.janet

diff --git a/janet/errors.janet b/janet/errors.janet
new file mode 100644
index 0000000..6e49987
--- /dev/null
+++ b/janet/errors.janet
@@ -0,0 +1,10 @@
+(import spork/json :as j)
+(import /base :as b)
+
+(defn scan-error [e out] (set (out :errors) e) (j/encode out))
+
+(defn parse-error [e out] (set (out :errors) e) (j/encode out))
+
+(defn validation-error [e out] (set (out :errors) e) (j/encode out))
+
+(defn runtime-error [e out] (set (out :errors) e) (j/encode out))
diff --git a/janet/ludus.janet b/janet/ludus.janet
index 2d1da13..d7e1680 100644
--- a/janet/ludus.janet
+++ b/janet/ludus.janet
@@ -1,40 +1,64 @@
 # an integrated Ludus interpreter
 (try (os/cd "janet") ([_] nil)) # for REPL
-(import ./scanner :as s)
-(import ./parser :as p)
-(import ./validate :as v)
-(import ./interpreter :as i)
+(import /scanner :as s)
+(import /parser :as p)
+(import /validate :as v)
+(import /interpreter :as i)
+(import /errors :as e)
+(import /base :as b)
+(import spork/json :as j)
 
-# (defn run []
-#   (def scanned (s/scan source))
-#   (when (has-errors? scanned) (break (scanned :errors)))
-#   (def parsed (p/parse scanned))
-#   (when (has-errors? parsed) (break (parsed :errors)))
-#   (def validated (v/valid parsed b/ctx))
-#   # (when (has-errors? validated) (break (validated :errors)))
-#   # (def cleaned (get-in parsed [:ast :data 1]))
-#   # # (pp cleaned)
-#   # (interpret (parsed :ast) @{:^parent b/ctx})
-#   (try (interpret (parsed :ast) @{:^parent b/ctx})
-#     ([e] (if (struct? e) (error (e :msg)) (error e)))))
+(comment
+The API from the old Clojure Ludus interpreter returns an object with four fields:
+ * `console`: an array of lines to be printed to the console
+ * `result`: a string representation of the result of running the script
+ * `draw`: an array of arrays that represent p5 calls, e.g. `["line", 0, 0, 100, 100]`
+ * `errors`: an array of errors, which are just strings
 
-(defn main [source]
+This new scene will have to return a JSON POJSO:
+{:console [...] :result "..." :draw [...] :errors [...]}
+)
+
+(def console @"")
+(setdyn :out console)
+(print "foo")
+(pp {:a 1 :b 2})
+(setdyn :out stdout)
+(print "collected out")
+(print console)
+
+(defn run [source]
+ (def errors @[])
+ (def draw @[])
+ (var result @"")
+ (def console @"")
+ (def out @{:errors errors :draw draw :result result :console console})
  (def scanned (s/scan source))
  (when (any? (scanned :errors))
-  (break (scanned :errors)))
+  (break (-> :errors scanned (e/scan-error out))))
  (def parsed (p/parse scanned))
  (when (any? (parsed :errors))
-  (break (parsed :errors)))
+  (break (-> :errors parsed (e/parse-error out))))
  (def validated (v/valid parsed))
  (when (any? (validated :errors))
-  (break (validated :errors)))
+  (break (-> :errors validated (e/validation-error out))))
+ (setdyn :out console)
  (try
-  (i/interpret (parsed :ast) @{})
-  ([e] (if (struct? e) (error (e :msg)) (error e)))))
+  (set result (b/show (i/interpret (parsed :ast) @{})))
+  ([err] (e/runtime-error err out)))
+ (set (out :result) result)
+ (j/encode out))
+
+(defn test [source])
+
+(defn run-script [filename]
+ (def source (slurp filename))
+ (run source))
 
 (def source `
  fn foo () -> :foo
- fool ()
+ foo ()
 `)
 
-(main source)
+(-> source run j/decode)
+