(in-package :cl-forth)

(defun main ()
  (let ((args (rest sb-ext:*posix-argv*)))
    (let ((flag (first args)))
      (cond ((string= flag "-c")
             ;; (iter (for (k v) in-hashtable *operations*)
             ;;       (for i from 0)
             ;;       (format t "~s: ~s~%" i k))
             ;; (let ((tokens (lex-file (second args))))
             ;;   (format t "~s~%" tokens)
             ;;   (let ((program (prog-from-tokens tokens)))
             ;;     (format t "~s~%" program)
             ;;     (generate-program program :compile t)))
             (generate-program (make-program (second args)) :compile t))
            ((string= flag "-p")
             (format t "~a" (make-program (second args))))
            ((string= flag "-t")
             (run-tests))
            ((string= flag "-s")
             (simulate-program (make-program (second args))))
            (t (format t "~a is not a valid flag~%" flag))))))

;; (defun make-exe ()
;;   (sb-ext:save-lisp-and-die #P"cl-forth"
;;                             :toplevel #'main
;;                             :executable t))

(defparameter *example-path* (from-root "test/prog.lorth"))

(defun example-lex ()
  (lex-file *example-path* t))

(defun example-prog ()
  (make-program *example-path*))

(defun example-compile ()
  (generate-program (make-program *example-path*) :path "test/output.asm"
                                                  :compile t))

(defun example-interpret ()
  (interpret-program (make-program *example-path*)))

(defun example-run ()
  (example-compile)
  (run '("test/output") :output t))

(defun start-forth-repl ()
  (iter (for line = (progn (format t "~&> ") (read-line)))
        (when (string= line "bye")
          (finish))
        (interpret-program (parse-tokens (lex-line line 0)))))