;; Running BROOD under snot.  Simply 'load' this file from within
;; snot, i.e. in ~/.snotrc


(require
 "console.ss"         ;; console actions without host && target state
 (lib "sandbox.ss"))  ;; with-limits


;; state is separated into 3 things:

;;    (T) target state    = microcontroller flash memory
;;    (M) target metadata = target dictionary + run time stack
;;    (H) host state      = transparently cached from source files

;; The idea is that we should be able to replace (H) without affecting
;; (T) and (M). In order to do this, both need to be separate. (T) is
;; external to the system, so we can ignore it and assume it's always
;; in sync with (M).

;; We store (M) here.

(define *target* (init-target))


;; We manage (H) in a sandbox using snot's "box" language, and use
;; "console.ss" to manage (M) outside of that sandbox.

(define (*host* expr)
  (with-limits #f #f ;;10 100
               (language-eval 'box expr)))

(define (brood-file str)
  (format "~a/~a" (brood-home) str))

(define (brood-reload)
  (set! *target* (strip *target*))
    
  (box-module-file (brood-file "host")
                   (brood-file "host/box.ss"))

  ;; boot: call prj-rep directly to avoid snot prompts.
  (set! *target*
        (prj-rep *target* *host*
                 "revert-macros"))

  (*host* `(current-directory ,(brood-file "")))

  
  ;; (language-rep 'prj "revert-macros")
  )





;; Convenience

(define-syntax rep 
  (syntax-rules ()
    ((_ delegate)
     (lambda (str)
       (set! *target*
             (delegate *target* *host* str))))))


(define (make-ns-completer . args) args)


(define ((not-implemented tag) . args)
  (error 'not-implemented "~a ~a" tag args))
                      

;; BASE

(register-language
 'base "base> "
 (lambda (expr) (base-eval *host* expr))
 (rep base-rep)
 (make-completer (base-wordlist *host*)))


;; PROJECT

(register-language
 'prj "prj> "
 (not-implemented 'prj-eval)
 (rep prj-rep)
 (make-completer (prj-wordlist *host*)))


;; MACRO

(register-language
 'macro ">> "
 (not-implemented 'macro-eval)
 (rep macro-rep)
 (make-completer (macro-wordlist *host*)))


;; LIVE

(register-language
 'live "> "
 (not-implemented 'live-eval)
 (rep live-rep)
 (make-completer (live-wordlist *host*)))

;; LIVE/VM

(register-language
 'live/vm "_> "
 (not-implemented 'live/vm-eval)
 (rep live/vm-rep)
 (make-completer (live/vm-wordlist *host*)))

;; MACRO

(register-language
 'macro/vm "_>> "
 (not-implemented 'macro/vm-eval)
 (rep macro/vm-rep)
 (make-completer (macro-wordlist *host*)))



;; JOY

;; ;; just a toy. load the "joy.ss" module in the sandbox for this to work.

;; (define (joy-rep str)
;;   (let ((expr (base-eval `(,str lex-line))))
;;     (prj-update!
;;      `(',expr i))))
     
   
;; (register-language 'joy "joy> "
;;                    (not-implemented 'joy-eval)
;;                    joy-rep
;;                    (make-ns-completer '((joy) (base))))




(repls '(image box box-macro base prj live macro live/vm macro/vm))

(run brood-reload)

;; (printf "BROOD loaded..\n")