;;; http://jscheme.sourceforge.net
(import "java.io.*")
(import "java.net.URL")
(import "java.util.regex.Pattern")

(load "elf/util.scm")
(load "elf/iterate.scm")

{
Pattern matching preserving type of files and urls.
Tim, we could make /// and //g File specific for this example.
}
(define (// pattern)
  (let ((p (Pattern.compile pattern)))
    (lambda (object)
      (.find (.matcher p (.toString object))))))

(define (/// pattern replacement)
  (let ((p (Pattern.compile pattern)))
    (lambda (object)
      (revert object
	      (.replaceFirst (.matcher p (.toString object)) replacement)))))

(define (///g pattern replacement)
  (let ((p (Pattern.compile pattern)))
    (lambda (object)
      (revert object
	      (.replaceAll (.matcher p (.toString object)) replacement)))))

{
Revert string back to an object.
}
(define-method (revert (in Object) string) string)
(define-method (revert (in URL)    string) (URL. string))
(define-method (revert (in File)   string) (File. string))

{
File searching
}
(define java->class (/// "\\.java$" ".class"))
(define isJavaFile (// "\\.java$"))

(define (files* directory type?) (filter type? (.listFiles directory)))
(define (directories directory) (files* directory .isDirectory))
(define (files** directory type?)
  (append (files* directory type?)
	  (apply append (map (lambda (d) (files** d type?))
			     (directories directory)))))
{
Is file up to date?
}
(define (needsRecompile f o)
  (or (not (.exists o)) (<= (.lastModified o) (.lastModified f))))

(define (needsUpdate? f) (needsRecompile f (java->class f)))

{
Run command
}

(define-macro (run . args) `(runRuntime ,(list 'quasiquote args)))

(define-macro (daemon . body)
  `(let ((it (Thread. (lambda () ,@body))))
     (.setDaemon it #t)
     it))

(define (runRuntime . args)
  (let* ((p (Process args)))
    (.start (daemon (drain (BufferedReader (.getErrorStream p)) System.out$)))
    (drain (BufferedReader (.getInputStream p)) System.out$) 
    (.waitFor p)))

(define (Process args)
  (.exec (Runtime.getRuntime)
	 (list->array String.class (map .toString (flatten args)))))

(define (drain r w) (iterate r (lambda (L) (.println w L))))

{
Compile all java files under dir.
}
(define (compile dir)
  (let ((files (filter needsUpdate? (files** dir isJavaFile))))
    (if (> (length files) 0)
	(begin
	  (display {Compiling [(length files)] files.\n})
	  (run javac -classpath ,dir ,files))
	(display {No files need compiling.\n}))))

{
Details
}
(define (flatten xs)
  (if (null? xs) '()
      (let ((it (car xs))
	    (xs (cdr xs)))
	(cond ((pair? it) (append (flatten it) (flatten xs)))
	      ((null? it) (flatten xs))
	      (else       (cons it (flatten xs)))))))

(define-method (BufferedReader (r Reader)) (BufferedReader. r))

(define-method (BufferedReader (s InputStream))
  (BufferedReader (InputStreamReader. s)))

(define-method (PrintWriter (s OutputStream))
  (PrintWriter (OutputStreamWriter. s)))

(define-method (PrintWriter (w Writer)) (PrintWriter. w))