#lang racket
;(require compatibility/mlist)
(require syntax/stx)
(require syntax/to-string)
(require "du-utility.scm")
(require "du-environment.scm")
(require "du-core.scm")
;(require "du-other.scm")
(require "du-operations.scm")
(require "du-reader.scm")
(provide dontuse-REPL eval-dontuse the-global-environment)
;
; dontuse a modular metaprogramming language
;
;;use-module-du-operations
(define (procedure-parameters p) (cadr p))
(define (procedure-body p) (caddr p))


(define (prompt-for-input string)
  (newline) (newline) (display string) (newline))

(define (announce-output string)
  (newline) (display string) (newline))

(define (user-print object)
  (if (compound-procedure? object)
      (display (list 'compound-procedure
                     (procedure-parameters object)
                     (procedure-body object)
                     '<procedure-env>))
      (cond ((string? object)
             (write object))
            ((not (tagged-list? object 'freeze))
             (write object))
            ((eq? (length object) 3)
             (write (caddr object)))
            ((eq? (length object) 2)
             (write (cadr object)))
            (else
             (error "slushy")))))

(define input-prompt ";;; dontuse input:")
(define output-prompt ";;; dontuse value:")

(define (dontuse-REPL)
  (prompt-for-input input-prompt)
  (let ((input (read-syntax #f (open-input-string (read-line)))))
    (let ((output
           (actual-value input the-global-environment)))
      (announce-output output-prompt)
      (user-print output))
  (dontuse-REPL)))

  
(define (eval-dontuse input)
    (let ((output
           (actual-value input the-global-environment)))
      (announce-output output-prompt)
      (user-print output)))

(put 'help 'version "(build 029  1-29-24)")
(define the-global-environment (setup-environment))
(newline)
(newline)
(display "Type 'help info' [Enter] for more information.")(newline)
(dontuse-REPL)
#|
some EVENT for basic I/O
more testing of STATE
more reuse for STATE (undo literal list constraint)
REPL in a state expression w/ hide catalog exit
isolation service
improved automated memory management: heap > stack > local


                   some tests
    ; "quote"
concat string imp quote concat string imp "quote" string imp quote
    ; (one 1 two 2 3 three)
state ((label one jump two) (label two)) (one number imp 1 two number imp 2 3 string imp "three")

    ; NOT working
 import export - not yet implemented
 subtypes, externals - not yet implemented

|#