107 lines
2.8 KiB
Plaintext
107 lines
2.8 KiB
Plaintext
# an integrated Ludus interpreter
|
|
# devised in order to run under wasm
|
|
# takes a string, returns a string with a json object
|
|
# (try (os/cd "janet") ([_] nil)) # for REPL
|
|
(import /src/scanner :as s)
|
|
(import /src/parser :as p)
|
|
(import /src/validate :as v)
|
|
(import /src/interpreter :as i)
|
|
(import /src/errors :as e)
|
|
(import /src/base :as b)
|
|
(import /src/prelude :as prelude)
|
|
(import /src/json :as j)
|
|
|
|
(defn ludus [source]
|
|
# if we can't load prelude, bail
|
|
(when (= :error prelude/pkg) (error "could not load prelude"))
|
|
|
|
# get us a clean working slate
|
|
(def ctx @{:^parent prelude/ctx})
|
|
(def errors @[])
|
|
(var result @"")
|
|
(def console @"")
|
|
|
|
# capture all `print`s
|
|
(setdyn :out console)
|
|
|
|
# an output table
|
|
# this will change: the shape of our output
|
|
# at the moment, there's only one stack of turtle graphics
|
|
# we will be getting more
|
|
(def out @{:errors errors :result result
|
|
:io @{
|
|
:stdout @{:proto [:text-stream "0.1.0"] :data console}
|
|
:turtle @{:proto [:turtle-graphics "0.1.0"] :data @[]}}})
|
|
|
|
### start the program
|
|
# first, scanning
|
|
(def scanned (s/scan source))
|
|
(when (any? (scanned :errors))
|
|
(each err (scanned :errors)
|
|
(e/scan-error err))
|
|
(break (-> out j/encode string)))
|
|
# then, parsing
|
|
(def parsed (p/parse scanned))
|
|
(when (any? (parsed :errors))
|
|
(each err (parsed :errors)
|
|
(e/parse-error err))
|
|
(break (-> out j/encode string)))
|
|
# then, validation
|
|
(def validated (v/valid parsed ctx))
|
|
(when (any? (validated :errors))
|
|
(each err (validated :errors)
|
|
(e/validation-error err))
|
|
(break (-> out j/encode string)))
|
|
# and, finally, try interpreting the program
|
|
(try (do
|
|
# we need to do this every run or we get the very same sequence of "random" numbers every time we run a program
|
|
(math/seedrandom (os/cryptorand 8))
|
|
(set result (i/interpret (parsed :ast) ctx)))
|
|
([err]
|
|
(e/runtime-error err)
|
|
(break (-> out j/encode string))))
|
|
|
|
# stop capturing output
|
|
(setdyn :out stdout)
|
|
|
|
# update our output table with our output
|
|
(set (out :result) (b/show result))
|
|
(set (((out :io) :turtle) :data) (get-in prelude/pkg [:turtle_commands :^value]))
|
|
|
|
# run the "postlude": any Ludus code that needs to run after each program
|
|
# right now this is just resetting the boxes that hold turtle commands and state
|
|
(try
|
|
(i/interpret prelude/post/ast ctx)
|
|
([err] (e/runtime-error err)))
|
|
|
|
# json-encode our output table, and convert it from a buffer to a string (which we require for playing nice with WASM/C)
|
|
(-> out j/encode string))
|
|
|
|
#### REPL
|
|
(comment
|
|
# (do
|
|
# (def start (os/clock))
|
|
(def source `
|
|
fd! (100)
|
|
rt! (0.25)
|
|
fd! (100)
|
|
lt! (0.25)
|
|
fd! (100)
|
|
setheading! (0.75)
|
|
unbox (turtle_state)
|
|
`)
|
|
(def out (-> source
|
|
ludus
|
|
j/decode
|
|
))
|
|
# (def end (os/clock))
|
|
(setdyn :out stdout)
|
|
(pp out)
|
|
(def console (out "console"))
|
|
(print console)
|
|
(def result (out "result"))
|
|
(print result)
|
|
# (print (- end start))
|
|
)
|
|
|